X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fmdt%2Fmdt_recovery.c;h=f93840ebd6769fc2eecad44013fb1e02b43c35dd;hb=1a7720934dfb3105afd2f025c953bea2167d4e5d;hp=0381a266a4ff05a277e69c3a7ce489c893d97ceb;hpb=2b294992edce5af7b79d4300ed3aa1ea6a8db850;p=fs%2Flustre-release.git diff --git a/lustre/mdt/mdt_recovery.c b/lustre/mdt/mdt_recovery.c index 0381a26..f93840e 100644 --- a/lustre/mdt/mdt_recovery.c +++ b/lustre/mdt/mdt_recovery.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) 2007, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2011, 2014, Intel Corporation. + * Copyright (c) 2011, 2017, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -71,17 +67,6 @@ const struct lu_buf *mdt_buf_const(const struct lu_env *env, return buf; } -void mdt_trans_stop(const struct lu_env *env, - struct mdt_device *mdt, struct thandle *th) -{ - dt_trans_stop(env, mdt->mdt_bottom, th); -} - -/* - * last_rcvd & last_committed update callbacks - */ -extern struct lu_context_key mdt_thread_key; - /* This callback notifies MDT that transaction was done. This is needed by * mdt_save_lock() only. It is similar to new target code and will be removed * as mdt_save_lock() will be converted to use target structures */ @@ -113,7 +98,6 @@ int mdt_fs_setup(const struct lu_env *env, struct mdt_device *mdt, /* prepare transactions callbacks */ mdt->mdt_txn_cb.dtc_txn_start = NULL; mdt->mdt_txn_cb.dtc_txn_stop = mdt_txn_stop_cb; - mdt->mdt_txn_cb.dtc_txn_commit = NULL; mdt->mdt_txn_cb.dtc_cookie = NULL; mdt->mdt_txn_cb.dtc_tag = LCT_MD_THREAD; INIT_LIST_HEAD(&mdt->mdt_txn_cb.dtc_linkage); @@ -129,9 +113,6 @@ void mdt_fs_cleanup(const struct lu_env *env, struct mdt_device *mdt) /* Remove transaction callback */ dt_txn_callback_del(mdt->mdt_bottom, &mdt->mdt_txn_cb); - if (mdt->mdt_ck_obj) - lu_object_put(env, &mdt->mdt_ck_obj->do_lu); - mdt->mdt_ck_obj = NULL; EXIT; } @@ -139,99 +120,100 @@ void mdt_fs_cleanup(const struct lu_env *env, struct mdt_device *mdt) static void mdt_steal_ack_locks(struct ptlrpc_request *req) { struct ptlrpc_service_part *svcpt; - struct obd_export *exp = req->rq_export; - struct list_head *tmp; - struct ptlrpc_reply_state *oldrep; - int i; + struct obd_export *exp = req->rq_export; + struct list_head *tmp; + struct ptlrpc_reply_state *rs; + int i; /* CAVEAT EMPTOR: spinlock order */ spin_lock(&exp->exp_lock); list_for_each(tmp, &exp->exp_outstanding_replies) { - oldrep = list_entry(tmp, struct ptlrpc_reply_state, + rs = list_entry(tmp, struct ptlrpc_reply_state, rs_exp_list); - if (oldrep->rs_xid != req->rq_xid) - continue; + if (rs->rs_xid != req->rq_xid) + continue; - if (oldrep->rs_opc != lustre_msg_get_opc(req->rq_reqmsg)) - CERROR ("Resent req xid "LPU64" has mismatched opc: " - "new %d old %d\n", req->rq_xid, - lustre_msg_get_opc(req->rq_reqmsg), - oldrep->rs_opc); - - svcpt = oldrep->rs_svcpt; - spin_lock(&svcpt->scp_rep_lock); + if (rs->rs_opc != lustre_msg_get_opc(req->rq_reqmsg)) + CERROR("%s: Resent req xid %llu has mismatched opc: " + "new %d old %d\n", exp->exp_obd->obd_name, + req->rq_xid, lustre_msg_get_opc(req->rq_reqmsg), + rs->rs_opc); - list_del_init(&oldrep->rs_exp_list); + svcpt = rs->rs_svcpt; - CDEBUG(D_HA, "Stealing %d locks from rs %p x"LPD64".t"LPD64 + CDEBUG(D_HA, "Stealing %d locks from rs %p x%lld.t%lld" " o%d NID %s\n", - oldrep->rs_nlocks, oldrep, - oldrep->rs_xid, oldrep->rs_transno, oldrep->rs_opc, - libcfs_nid2str(exp->exp_connection->c_peer.nid)); + rs->rs_nlocks, rs, + rs->rs_xid, rs->rs_transno, rs->rs_opc, + obd_export_nid2str(exp)); - for (i = 0; i < oldrep->rs_nlocks; i++) - ptlrpc_save_lock(req, &oldrep->rs_locks[i], - oldrep->rs_modes[i], 0); - oldrep->rs_nlocks = 0; + spin_lock(&svcpt->scp_rep_lock); + list_del_init(&rs->rs_exp_list); + + spin_lock(&rs->rs_lock); + for (i = 0; i < rs->rs_nlocks; i++) + ptlrpc_save_lock(req, &rs->rs_locks[i], + rs->rs_modes[i], rs->rs_no_ack, + rs->rs_convert_lock); + rs->rs_nlocks = 0; - DEBUG_REQ(D_HA, req, "stole locks for"); - spin_lock(&oldrep->rs_lock); - ptlrpc_schedule_difficult_reply(oldrep); - spin_unlock(&oldrep->rs_lock); + DEBUG_REQ(D_HA, req, "stole locks for"); + ptlrpc_schedule_difficult_reply(rs); + spin_unlock(&rs->rs_lock); spin_unlock(&svcpt->scp_rep_lock); break; } spin_unlock(&exp->exp_lock); -} -/** - * VBR: restore versions - */ -void mdt_vbr_reconstruct(struct ptlrpc_request *req, - struct lsd_client_data *lcd) -{ - __u64 pre_versions[4] = {0}; - pre_versions[0] = lcd->lcd_pre_versions[0]; - pre_versions[1] = lcd->lcd_pre_versions[1]; - pre_versions[2] = lcd->lcd_pre_versions[2]; - pre_versions[3] = lcd->lcd_pre_versions[3]; - lustre_msg_set_versions(req->rq_repmsg, pre_versions); + /* if exp_disconnected, decref stolen locks */ + if (exp->exp_disconnected) { + rs = req->rq_reply_state; + + for (i = 0; i < rs->rs_nlocks; i++) + ldlm_lock_decref(&rs->rs_locks[i], rs->rs_modes[i]); + + rs->rs_nlocks = 0; + } } -void mdt_req_from_lcd(struct ptlrpc_request *req, - struct lsd_client_data *lcd) +__u64 mdt_req_from_lrd(struct ptlrpc_request *req, + struct tg_reply_data *trd) { - DEBUG_REQ(D_HA, req, "restoring transno "LPD64"/status %d", - lcd->lcd_last_transno, lcd->lcd_last_result); - - if (lustre_msg_get_opc(req->rq_reqmsg) == MDS_CLOSE || - lustre_msg_get_opc(req->rq_repmsg) == MDS_DONE_WRITING) { - req->rq_transno = lcd->lcd_last_close_transno; - req->rq_status = lcd->lcd_last_close_result; - } else { - req->rq_transno = lcd->lcd_last_transno; - req->rq_status = lcd->lcd_last_result; - mdt_vbr_reconstruct(req, lcd); - } - if (req->rq_status != 0) - req->rq_transno = 0; - lustre_msg_set_transno(req->rq_repmsg, req->rq_transno); - lustre_msg_set_status(req->rq_repmsg, req->rq_status); - DEBUG_REQ(D_RPCTRACE, req, "restoring transno "LPD64"/status %d", - req->rq_transno, req->rq_status); - - mdt_steal_ack_locks(req); + struct lsd_reply_data *lrd; + + LASSERT(trd != NULL); + lrd = &trd->trd_reply; + + DEBUG_REQ(D_HA, req, "restoring transno %lld/status %d", + lrd->lrd_transno, lrd->lrd_result); + + req->rq_transno = lrd->lrd_transno; + req->rq_status = lrd->lrd_result; + + lustre_msg_set_versions(req->rq_repmsg, trd->trd_pre_versions); + + if (req->rq_status != 0) + req->rq_transno = 0; + lustre_msg_set_transno(req->rq_repmsg, req->rq_transno); + lustre_msg_set_status(req->rq_repmsg, req->rq_status); + + DEBUG_REQ(D_RPCTRACE, req, "restoring transno %lld/status %d", + req->rq_transno, req->rq_status); + + mdt_steal_ack_locks(req); + + return lrd->lrd_data; } + void mdt_reconstruct_generic(struct mdt_thread_info *mti, - struct mdt_lock_handle *lhc) + struct mdt_lock_handle *lhc) { - struct ptlrpc_request *req = mdt_info_req(mti); - struct tg_export_data *ted = &req->rq_export->exp_target_data; + struct ptlrpc_request *req = mdt_info_req(mti); - return mdt_req_from_lcd(req, ted->ted_lcd); + mdt_req_from_lrd(req, mti->mti_reply_data); } /** @@ -257,17 +239,16 @@ static void mdt_fake_ma(struct md_attr *ma) static void mdt_reconstruct_create(struct mdt_thread_info *mti, struct mdt_lock_handle *lhc) { - struct ptlrpc_request *req = mdt_info_req(mti); - struct obd_export *exp = req->rq_export; - struct tg_export_data *ted = &exp->exp_target_data; - struct mdt_device *mdt = mti->mti_mdt; - struct mdt_object *child; - struct mdt_body *body; - int rc; + struct ptlrpc_request *req = mdt_info_req(mti); + struct obd_export *exp = req->rq_export; + struct mdt_device *mdt = mti->mti_mdt; + struct mdt_object *child; + struct mdt_body *body; + int rc; - mdt_req_from_lcd(req, ted->ted_lcd); - if (req->rq_status) - return; + mdt_req_from_lrd(req, mti->mti_reply_data); + if (req->rq_status) + return; /* if no error, so child was created with requested fid */ child = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid2); @@ -307,15 +288,14 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, { struct ptlrpc_request *req = mdt_info_req(mti); struct obd_export *exp = req->rq_export; - struct mdt_export_data *med = &exp->exp_mdt_data; struct mdt_device *mdt = mti->mti_mdt; struct mdt_object *obj; struct mdt_body *body; int rc; - mdt_req_from_lcd(req, med->med_ted.ted_lcd); - if (req->rq_status) - return; + mdt_req_from_lrd(req, mti->mti_reply_data); + if (req->rq_status) + return; body = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY); obj = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid1); @@ -338,21 +318,6 @@ static void mdt_reconstruct_setattr(struct mdt_thread_info *mti, mdt_fake_ma(&mti->mti_attr); mdt_pack_attr2body(mti, body, &mti->mti_attr.ma_attr, mdt_object_fid(obj)); - if (mti->mti_ioepoch && (mti->mti_ioepoch->flags & MF_EPOCH_OPEN)) { - struct mdt_file_data *mfd; - struct mdt_body *repbody; - - repbody = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY); - repbody->mbo_ioepoch = obj->mot_ioepoch; - spin_lock(&med->med_open_lock); - list_for_each_entry(mfd, &med->med_open_head, mfd_list) { - if (mfd->mfd_xid == req->rq_xid) - break; - } - LASSERT(&mfd->mfd_list != &med->med_open_head); - spin_unlock(&med->med_open_lock); - repbody->mbo_handle.cookie = mfd->mfd_handle.h_cookie; - } mdt_object_put(mti->mti_env, obj); } @@ -367,13 +332,19 @@ static mdt_reconstructor reconstructors[REINT_MAX] = { [REINT_UNLINK] = mdt_reconstruct_generic, [REINT_RENAME] = mdt_reconstruct_generic, [REINT_OPEN] = mdt_reconstruct_open, - [REINT_SETXATTR] = mdt_reconstruct_generic + [REINT_SETXATTR] = mdt_reconstruct_generic, + [REINT_RMENTRY] = mdt_reconstruct_generic, + [REINT_MIGRATE] = mdt_reconstruct_generic, + [REINT_RESYNC] = mdt_reconstruct_generic }; void mdt_reconstruct(struct mdt_thread_info *mti, struct mdt_lock_handle *lhc) { + mdt_reconstructor reconst; ENTRY; - reconstructors[mti->mti_rr.rr_opcode](mti, lhc); + LASSERT(mti->mti_rr.rr_opcode < REINT_MAX && + (reconst = reconstructors[mti->mti_rr.rr_opcode]) != NULL); + reconst(mti, lhc); EXIT; }