X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lustre%2Fldlm%2Fldlm_lib.c;h=ea5af07d43c2cd64193d5480f0fdbba23d07f102;hb=a8dcf372f430c308d3e96fb506563068d0a80c2d;hp=f863f133c67401e3247a98a02e918c9842ae9808;hpb=500f334631c6ebec72f5791472f21603da3e0ef9;p=fs%2Flustre-release.git diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index f863f13..ea5af07 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.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) 2003, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. * - * Copyright (c) 2010, 2015, Intel Corporation. + * Copyright (c) 2010, 2016, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -58,71 +54,75 @@ static int import_set_conn(struct obd_import *imp, struct obd_uuid *uuid, int priority, int create) { - struct ptlrpc_connection *ptlrpc_conn; - struct obd_import_conn *imp_conn = NULL, *item; - int rc = 0; - ENTRY; + struct ptlrpc_connection *ptlrpc_conn; + struct obd_import_conn *imp_conn = NULL, *item; + lnet_nid_t nid4refnet = LNET_NID_ANY; + int rc = 0; + ENTRY; - if (!create && !priority) { - CDEBUG(D_HA, "Nothing to do\n"); - RETURN(-EINVAL); - } + if (!create && !priority) { + CDEBUG(D_HA, "Nothing to do\n"); + RETURN(-EINVAL); + } - ptlrpc_conn = ptlrpc_uuid_to_connection(uuid); - if (!ptlrpc_conn) { - CDEBUG(D_HA, "can't find connection %s\n", uuid->uuid); - RETURN (-ENOENT); - } + if (imp->imp_connection && + imp->imp_connection->c_remote_uuid.uuid[0] == 0) + /* nid4refnet is used to restrict network connections */ + nid4refnet = imp->imp_connection->c_self; + ptlrpc_conn = ptlrpc_uuid_to_connection(uuid, nid4refnet); + if (!ptlrpc_conn) { + CDEBUG(D_HA, "can't find connection %s\n", uuid->uuid); + RETURN(-ENOENT); + } - if (create) { - OBD_ALLOC(imp_conn, sizeof(*imp_conn)); - if (!imp_conn) { - GOTO(out_put, rc = -ENOMEM); - } - } + if (create) { + OBD_ALLOC(imp_conn, sizeof(*imp_conn)); + if (!imp_conn) + GOTO(out_put, rc = -ENOMEM); + } spin_lock(&imp->imp_lock); list_for_each_entry(item, &imp->imp_conn_list, oic_item) { - if (obd_uuid_equals(uuid, &item->oic_uuid)) { - if (priority) { + if (obd_uuid_equals(uuid, &item->oic_uuid)) { + if (priority) { list_del(&item->oic_item); list_add(&item->oic_item, - &imp->imp_conn_list); - item->oic_last_attempt = 0; - } - CDEBUG(D_HA, "imp %p@%s: found existing conn %s%s\n", - imp, imp->imp_obd->obd_name, uuid->uuid, - (priority ? ", moved to head" : "")); + &imp->imp_conn_list); + item->oic_last_attempt = 0; + } + CDEBUG(D_HA, "imp %p@%s: found existing conn %s%s\n", + imp, imp->imp_obd->obd_name, uuid->uuid, + (priority ? ", moved to head" : "")); spin_unlock(&imp->imp_lock); - GOTO(out_free, rc = 0); - } - } + GOTO(out_free, rc = 0); + } + } /* No existing import connection found for \a uuid. */ - if (create) { - imp_conn->oic_conn = ptlrpc_conn; - imp_conn->oic_uuid = *uuid; - imp_conn->oic_last_attempt = 0; - if (priority) + if (create) { + imp_conn->oic_conn = ptlrpc_conn; + imp_conn->oic_uuid = *uuid; + imp_conn->oic_last_attempt = 0; + if (priority) list_add(&imp_conn->oic_item, &imp->imp_conn_list); - else + else list_add_tail(&imp_conn->oic_item, - &imp->imp_conn_list); - CDEBUG(D_HA, "imp %p@%s: add connection %s at %s\n", - imp, imp->imp_obd->obd_name, uuid->uuid, - (priority ? "head" : "tail")); - } else { + &imp->imp_conn_list); + CDEBUG(D_HA, "imp %p@%s: add connection %s at %s\n", + imp, imp->imp_obd->obd_name, uuid->uuid, + (priority ? "head" : "tail")); + } else { spin_unlock(&imp->imp_lock); GOTO(out_free, rc = -ENOENT); } spin_unlock(&imp->imp_lock); - RETURN(0); + RETURN(0); out_free: - if (imp_conn) - OBD_FREE(imp_conn, sizeof(*imp_conn)); + if (imp_conn) + OBD_FREE(imp_conn, sizeof(*imp_conn)); out_put: - ptlrpc_connection_put(ptlrpc_conn); - RETURN(rc); + ptlrpc_connection_put(ptlrpc_conn); + RETURN(rc); } int import_set_conn_priority(struct obd_import *imp, struct obd_uuid *uuid) @@ -167,14 +167,17 @@ int client_import_del_conn(struct obd_import *imp, struct obd_uuid *uuid) ptlrpc_connection_put(imp->imp_connection); imp->imp_connection = NULL; - dlmexp = class_conn2export(&imp->imp_dlm_handle); - if (dlmexp && dlmexp->exp_connection) { - LASSERT(dlmexp->exp_connection == - imp_conn->oic_conn); - ptlrpc_connection_put(dlmexp->exp_connection); - dlmexp->exp_connection = NULL; - } - } + dlmexp = class_conn2export(&imp->imp_dlm_handle); + if (dlmexp && dlmexp->exp_connection) { + LASSERT(dlmexp->exp_connection == + imp_conn->oic_conn); + ptlrpc_connection_put(dlmexp->exp_connection); + dlmexp->exp_connection = NULL; + } + + if (dlmexp != NULL) + class_export_put(dlmexp); + } list_del(&imp_conn->oic_item); ptlrpc_connection_put(imp_conn->oic_conn); @@ -257,6 +260,7 @@ static int osc_on_mdt(char *obdname) * 1 - client UUID * 2 - server UUID * 3 - inactive-on-startup + * 4 - restrictive net */ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) { @@ -267,6 +271,8 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) char *name = obddev->obd_type->typ_name; enum ldlm_ns_type ns_type = LDLM_NS_TYPE_UNKNOWN; char *cli_name = lustre_cfg_buf(lcfg, 0); + struct ptlrpc_connection fake_conn = { .c_self = 0, + .c_remote_uuid.uuid[0] = 0 }; int rc; ENTRY; @@ -344,10 +350,12 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) init_rwsem(&cli->cl_sem); mutex_init(&cli->cl_mgc_mutex); - cli->cl_conn_count = 0; - memcpy(server_uuid.uuid, lustre_cfg_buf(lcfg, 2), - min_t(unsigned int, LUSTRE_CFG_BUFLEN(lcfg, 2), - sizeof(server_uuid))); + cli->cl_seq = NULL; + init_rwsem(&cli->cl_seq_rwsem); + cli->cl_conn_count = 0; + memcpy(server_uuid.uuid, lustre_cfg_buf(lcfg, 2), + min_t(unsigned int, LUSTRE_CFG_BUFLEN(lcfg, 2), + sizeof(server_uuid))); cli->cl_dirty_pages = 0; cli->cl_avail_grant = 0; @@ -401,17 +409,17 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) * from OFD after connecting. */ cli->cl_max_pages_per_rpc = PTLRPC_MAX_BRW_PAGES; - /* set cl_chunkbits default value to PAGE_CACHE_SHIFT, + /* set cl_chunkbits default value to PAGE_SHIFT, * it will be updated at OSC connection time. */ - cli->cl_chunkbits = PAGE_CACHE_SHIFT; + cli->cl_chunkbits = PAGE_SHIFT; if (!strcmp(name, LUSTRE_MDC_NAME)) { cli->cl_max_rpcs_in_flight = OBD_MAX_RIF_DEFAULT; - } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 128 /* MB */) { + } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 128 /* MB */) { cli->cl_max_rpcs_in_flight = 2; - } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 256 /* MB */) { + } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 256 /* MB */) { cli->cl_max_rpcs_in_flight = 3; - } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 512 /* MB */) { + } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 512 /* MB */) { cli->cl_max_rpcs_in_flight = 4; } else { if (osc_on_mdt(obddev->obd_name)) @@ -428,6 +436,8 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) init_waitqueue_head(&cli->cl_mod_rpcs_waitq); cli->cl_mod_tag_bitmap = NULL; + INIT_LIST_HEAD(&cli->cl_chg_dev_linkage); + if (connect_op == MDS_CONNECT) { cli->cl_max_mod_rpcs_in_flight = cli->cl_max_rpcs_in_flight - 1; OBD_ALLOC(cli->cl_mod_tag_bitmap, @@ -454,11 +464,26 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg) LUSTRE_CFG_BUFLEN(lcfg, 1)); class_import_put(imp); - rc = client_import_add_conn(imp, &server_uuid, 1); - if (rc) { - CERROR("can't add initial connection\n"); - GOTO(err_import, rc); - } + if (lustre_cfg_buf(lcfg, 4)) { + __u32 refnet = libcfs_str2net(lustre_cfg_string(lcfg, 4)); + + if (refnet == LNET_NIDNET(LNET_NID_ANY)) { + rc = -EINVAL; + CERROR("%s: bad mount option 'network=%s': rc = %d\n", + obddev->obd_name, lustre_cfg_string(lcfg, 4), + rc); + GOTO(err_import, rc); + } + fake_conn.c_self = LNET_MKNID(refnet, 0); + imp->imp_connection = &fake_conn; + } + + rc = client_import_add_conn(imp, &server_uuid, 1); + if (rc) { + CERROR("can't add initial connection\n"); + GOTO(err_import, rc); + } + imp->imp_connection = NULL; cli->cl_import = imp; /* cli->cl_max_mds_easize updated by mdc_init_ea_size() */ @@ -534,7 +559,6 @@ int client_connect_import(const struct lu_env *env, struct obd_connect_data *ocd; struct lustre_handle conn = { 0 }; int rc; - bool is_mdc = false; ENTRY; *exp = NULL; @@ -559,18 +583,12 @@ int client_connect_import(const struct lu_env *env, ocd = &imp->imp_connect_data; if (data) { *ocd = *data; - is_mdc = strncmp(imp->imp_obd->obd_type->typ_name, - LUSTRE_MDC_NAME, 3) == 0; - if (is_mdc) - data->ocd_connect_flags |= OBD_CONNECT_MULTIMODRPCS; imp->imp_connect_flags_orig = data->ocd_connect_flags; imp->imp_connect_flags2_orig = data->ocd_connect_flags2; } rc = ptlrpc_connect_import(imp); if (rc != 0) { - if (data && is_mdc) - data->ocd_connect_flags &= ~OBD_CONNECT_MULTIMODRPCS; LASSERT(imp->imp_state == LUSTRE_IMP_DISCON); GOTO(out_ldlm, rc); } @@ -581,10 +599,7 @@ int client_connect_import(const struct lu_env *env, ocd->ocd_connect_flags, "old %#llx, new %#llx\n", data->ocd_connect_flags, ocd->ocd_connect_flags); data->ocd_connect_flags = ocd->ocd_connect_flags; - /* clear the flag as it was not set and is not known - * by upper layers */ - if (is_mdc) - data->ocd_connect_flags &= ~OBD_CONNECT_MULTIMODRPCS; + data->ocd_connect_flags2 = ocd->ocd_connect_flags2; } ptlrpc_pinger_add_import(imp); @@ -702,7 +717,10 @@ int server_disconnect_export(struct obd_export *exp) spin_lock(&svcpt->scp_rep_lock); list_del_init(&rs->rs_exp_list); + spin_lock(&rs->rs_lock); + /* clear rs_convert_lock to make sure rs is handled and put */ + rs->rs_convert_lock = 0; ptlrpc_schedule_difficult_reply(rs); spin_unlock(&rs->rs_lock); @@ -764,16 +782,38 @@ static int target_handle_reconnect(struct lustre_handle *conn, } now = cfs_time_current(); - deadline = cfs_timer_deadline(&target->obd_recovery_timer); + deadline = target->obd_recovery_timer.expires; if (cfs_time_before(now, deadline)) { + struct target_distribute_txn_data *tdtd = + class_exp2tgt(exp)->lut_tdtd; + int size = 0; + int count = 0; + char *buf = NULL; + timeout = cfs_duration_sec(cfs_time_sub(deadline, now)); - LCONSOLE_WARN("%s: Client %s (at %s) reconnecting," - " waiting for %d clients in recovery for" - " %d:%.02d\n", target->obd_name, - obd_uuid2str(&exp->exp_client_uuid), - obd_export_nid2str(exp), - target->obd_max_recoverable_clients, - timeout / 60, timeout % 60); + if (tdtd && tdtd->tdtd_show_update_logs_retrievers) + buf = tdtd->tdtd_show_update_logs_retrievers( + tdtd->tdtd_show_retrievers_cbdata, + &size, &count); + + if (count > 0) + LCONSOLE_WARN("%s: Recovery already passed deadline " + "%d:%.02d. It is due to DNE recovery " + "failed/stuck on the %d MDT(s):%s. " + "Please wait until all MDTs recovered " + "or abort the recovery by force.\n", + target->obd_name, timeout / 60, + timeout % 60, count, + buf ? buf : "unknown (not enough RAM)"); + else + LCONSOLE_WARN("%s: Recovery already passed deadline " + "%d:%.02d. If you do not want to wait " + "more, please abort the recovery by " + "force.\n", target->obd_name, + timeout / 60, timeout % 60); + + if (buf != NULL) + OBD_FREE(buf, size); } else { timeout = cfs_duration_sec(cfs_time_sub(now, deadline)); LCONSOLE_WARN("%s: Recovery already passed deadline" @@ -791,20 +831,6 @@ out_already: RETURN(EALREADY); } -void target_client_add_cb(struct obd_device *obd, __u64 transno, void *cb_data, - int error) -{ - struct obd_export *exp = cb_data; - - CDEBUG(D_RPCTRACE, "%s: committing for initial connect of %s\n", - obd->obd_name, exp->exp_client_uuid.uuid); - - spin_lock(&exp->exp_lock); - exp->exp_need_sync = 0; - spin_unlock(&exp->exp_lock); - class_export_cb_put(exp); -} - static void check_and_start_recovery_timer(struct obd_device *obd, struct ptlrpc_request *req, int new_client); @@ -931,7 +957,7 @@ int target_handle_connect(struct ptlrpc_request *req) int rc = 0; char *target_start; int target_len; - bool mds_conn = false, lw_client = false; + bool mds_conn = false, lw_client = false, initial_conn = false; bool mds_mds_conn = false; bool new_mds_mds_conn = false; bool target_referenced = false; @@ -1063,6 +1089,7 @@ int target_handle_connect(struct ptlrpc_request *req) lw_client = (data->ocd_connect_flags & OBD_CONNECT_LIGHTWEIGHT) != 0; if (lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_INITIAL) { + initial_conn = true; mds_conn = (data->ocd_connect_flags & OBD_CONNECT_MDS) != 0; mds_mds_conn = (data->ocd_connect_flags & OBD_CONNECT_MDS_MDS) != 0; @@ -1120,8 +1147,8 @@ int target_handle_connect(struct ptlrpc_request *req) class_export_put(export); export = NULL; rc = -EALREADY; - } else if ((mds_conn || lw_client || - data->ocd_connect_flags & OBD_CONNECT_MDS_MDS) && + } else if ((mds_conn || (lw_client && initial_conn) || + data->ocd_connect_flags & OBD_CONNECT_MDS_MDS) && export->exp_connection != NULL) { spin_unlock(&export->exp_lock); if (req->rq_peer.nid != export->exp_connection->c_peer.nid) { @@ -1157,10 +1184,8 @@ int target_handle_connect(struct ptlrpc_request *req) export = NULL; rc = 0; } - } else if (export->exp_connection != NULL && - req->rq_peer.nid != export->exp_connection->c_peer.nid && - (lustre_msg_get_op_flags(req->rq_reqmsg) & - MSG_CONNECT_INITIAL)) { + } else if (export->exp_connection != NULL && initial_conn && + req->rq_peer.nid != export->exp_connection->c_peer.nid) { spin_unlock(&export->exp_lock); /* In MDS failover we have static UUID but NID can change. */ LCONSOLE_WARN("%s: Client %s seen on new nid %s when " @@ -1248,7 +1273,7 @@ no_export: i = atomic_read(&target->obd_lock_replay_clients); k = target->obd_max_recoverable_clients; s = target->obd_stale_clients; - t = cfs_timer_deadline(&target->obd_recovery_timer); + t = target->obd_recovery_timer.expires; t = cfs_time_sub(t, cfs_time_current()); t = cfs_duration_sec(t); LCONSOLE_WARN("%s: Denying connection for new client %s" @@ -1551,18 +1576,20 @@ static void target_finish_recovery(struct lu_target *lut) /* Only log a recovery message when recovery has occurred. */ if (obd->obd_recovery_start) { - time_t elapsed_time = max_t(time_t, 1, cfs_time_current_sec() - - obd->obd_recovery_start); - LCONSOLE_INFO("%s: Recovery over after %d:%.02d, of %d clients " + time64_t now = ktime_get_real_seconds(); + time64_t elapsed_time; + + elapsed_time = max_t(time64_t, now - obd->obd_recovery_start, 1); + LCONSOLE_INFO("%s: Recovery over after %lld:%.02lld, of %d clients " "%d recovered and %d %s evicted.\n", obd->obd_name, - (int)elapsed_time / 60, (int)elapsed_time % 60, + (s64)elapsed_time / 60, (s64)elapsed_time % 60, obd->obd_max_recoverable_clients, atomic_read(&obd->obd_connected_clients), obd->obd_stale_clients, obd->obd_stale_clients == 1 ? "was" : "were"); } - ldlm_reprocess_all_ns(obd->obd_namespace); + ldlm_reprocess_recovery_done(obd->obd_namespace); spin_lock(&obd->obd_recovery_task_lock); if (!list_empty(&obd->obd_req_replay_queue) || !list_empty(&obd->obd_lock_replay_queue) || @@ -1579,7 +1606,7 @@ static void target_finish_recovery(struct lu_target *lut) } spin_unlock(&obd->obd_recovery_task_lock); - obd->obd_recovery_end = cfs_time_current_sec(); + obd->obd_recovery_end = ktime_get_real_seconds(); /* When recovery finished, cleanup orphans on MDS and OST. */ if (OBT(obd) && OBP(obd, postrecov)) { @@ -1685,7 +1712,7 @@ EXPORT_SYMBOL(target_cleanup_recovery); void target_cancel_recovery_timer(struct obd_device *obd) { CDEBUG(D_HA, "%s: cancel recovery timer\n", obd->obd_name); - cfs_timer_disarm(&obd->obd_recovery_timer); + del_timer(&obd->obd_recovery_timer); } static void target_start_recovery_timer(struct obd_device *obd) @@ -1706,19 +1733,18 @@ static void target_start_recovery_timer(struct obd_device *obd) return; } - cfs_timer_arm(&obd->obd_recovery_timer, - cfs_time_shift(obd->obd_recovery_timeout)); - obd->obd_recovery_start = cfs_time_current_sec(); + mod_timer(&obd->obd_recovery_timer, + cfs_time_shift(obd->obd_recovery_timeout)); + obd->obd_recovery_start = ktime_get_real_seconds(); spin_unlock(&obd->obd_dev_lock); - LCONSOLE_WARN("%s: Will be in recovery for at least %d:%.02d, " - "or until %d client%s reconnect%s\n", - obd->obd_name, - obd->obd_recovery_timeout / 60, - obd->obd_recovery_timeout % 60, - obd->obd_max_recoverable_clients, - (obd->obd_max_recoverable_clients == 1) ? "" : "s", - (obd->obd_max_recoverable_clients == 1) ? "s": ""); + LCONSOLE_WARN("%s: Will be in recovery for at least %llu:%02llu, or until %d client%s reconnect%s\n", + obd->obd_name, + obd->obd_recovery_timeout / 60, + obd->obd_recovery_timeout % 60, + obd->obd_max_recoverable_clients, + (obd->obd_max_recoverable_clients == 1) ? "" : "s", + (obd->obd_max_recoverable_clients == 1) ? "s": ""); } /** @@ -1727,24 +1753,25 @@ static void target_start_recovery_timer(struct obd_device *obd) * if @extend is true, extend recovery window to have @drt remaining at least; * otherwise, make sure the recovery timeout value is not less than @drt. */ -static void extend_recovery_timer(struct obd_device *obd, int drt, bool extend) +static void extend_recovery_timer(struct obd_device *obd, int drt, + bool extend) { - cfs_time_t now; - cfs_time_t end; - cfs_duration_t left; - int to; + time64_t now; + time64_t end; + time64_t left; + time64_t to; spin_lock(&obd->obd_dev_lock); if (!obd->obd_recovering || obd->obd_abort_recovery) { spin_unlock(&obd->obd_dev_lock); - return; - } - LASSERT(obd->obd_recovery_start != 0); + return; + } + LASSERT(obd->obd_recovery_start != 0); - now = cfs_time_current_sec(); - to = obd->obd_recovery_timeout; - end = obd->obd_recovery_start + to; - left = cfs_time_sub(end, now); + now = ktime_get_real_seconds(); + to = obd->obd_recovery_timeout; + end = obd->obd_recovery_start + to; + left = end - now; if (extend && (drt > left)) { to += drt - left; @@ -1752,18 +1779,22 @@ static void extend_recovery_timer(struct obd_device *obd, int drt, bool extend) to = drt; } - if (to > obd->obd_recovery_time_hard) - to = obd->obd_recovery_time_hard; + if (to > obd->obd_recovery_time_hard) { + to = obd->obd_recovery_time_hard; + CWARN("%s: extended recovery timer reaching hard limit: %lld, extend: %d\n", + obd->obd_name, to, extend); + } + if (obd->obd_recovery_timeout < to) { obd->obd_recovery_timeout = to; end = obd->obd_recovery_start + to; - cfs_timer_arm(&obd->obd_recovery_timer, - cfs_time_shift(end - now)); + mod_timer(&obd->obd_recovery_timer, + cfs_time_shift(end - now)); } spin_unlock(&obd->obd_dev_lock); - CDEBUG(D_HA, "%s: recovery timer will expire in %u seconds\n", - obd->obd_name, (unsigned)cfs_time_sub(end, now)); + CDEBUG(D_HA, "%s: recovery timer will expire in %lld seconds\n", + obd->obd_name, (s64)(end - now)); } /* Reset the timer with each new client connection */ @@ -1797,6 +1828,10 @@ check_and_start_recovery_timer(struct obd_device *obd, * and reuse service_time to limit stack usage. */ service_time = at_est2timeout(service_time); + if (OBD_FAIL_CHECK(OBD_FAIL_TGT_SLUGGISH_NET) && + service_time < at_extra) + service_time = at_extra; + /* We expect other clients to timeout within service_time, then try * to reconnect, then try the failover server. The max delay between * connect attempts is SWITCH_MAX + SWITCH_INC + INITIAL. */ @@ -1963,8 +1998,8 @@ static int target_recovery_overseer(struct lu_target *lut, struct obd_device *obd = lut->lut_obd; struct target_distribute_txn_data *tdtd; repeat: - if ((obd->obd_recovery_start != 0) && (cfs_time_current_sec() >= - (obd->obd_recovery_start + obd->obd_recovery_time_hard))) { + if (obd->obd_recovery_start != 0 && ktime_get_real_seconds() >= + (obd->obd_recovery_start + obd->obd_recovery_time_hard)) { __u64 next_update_transno = 0; /* Only abort the recovery if there are no update recovery @@ -2033,7 +2068,6 @@ repeat: atomic_read(&tdtd->tdtd_recovery_threads_count) == 0, &lwi); /* Then abort the update recovery list */ - dtrq_list_dump(lut->lut_tdtd, D_ERROR); dtrq_list_destroy(lut->lut_tdtd); } @@ -2188,12 +2222,9 @@ static int check_for_recovery_ready(struct lu_target *lut) * timer expired, and some clients got evicted */ extend_recovery_timer(obd, obd->obd_recovery_timeout, true); - CDEBUG(D_HA, "%s update recovery is not ready," - " extend recovery %d\n", obd->obd_name, - obd->obd_recovery_timeout); + CDEBUG(D_HA, "%s update recovery is not ready, extend recovery %llu\n", + obd->obd_name, obd->obd_recovery_timeout); return 0; - } else { - dtrq_list_dump(lut->lut_tdtd, D_HA); } } @@ -2595,9 +2626,9 @@ static void target_recovery_expired(unsigned long castmeharder) { struct obd_device *obd = (struct obd_device *)castmeharder; CDEBUG(D_HA, "%s: recovery timed out; %d clients are still in recovery" - " after %lds (%d clients connected)\n", + " after %llus (%d clients connected)\n", obd->obd_name, atomic_read(&obd->obd_lock_replay_clients), - cfs_time_current_sec()- obd->obd_recovery_start, + (s64)(ktime_get_real_seconds() - obd->obd_recovery_start), atomic_read(&obd->obd_connected_clients)); obd->obd_recovery_expired = 1; @@ -2606,13 +2637,16 @@ static void target_recovery_expired(unsigned long castmeharder) void target_recovery_init(struct lu_target *lut, svc_handler_t handler) { - struct obd_device *obd = lut->lut_obd; + struct obd_device *obd = lut->lut_obd; - if (obd->obd_max_recoverable_clients == 0) { - /** Update server last boot epoch */ - tgt_boot_epoch_update(lut); - return; - } + if (lut->lut_bottom->dd_rdonly) + return; + + if (obd->obd_max_recoverable_clients == 0) { + /** Update server last boot epoch */ + tgt_boot_epoch_update(lut); + return; + } CDEBUG(D_HA, "RECOVERY: service %s, %d recoverable clients, " "last_transno %llu\n", obd->obd_name, @@ -2622,8 +2656,9 @@ void target_recovery_init(struct lu_target *lut, svc_handler_t handler) obd->obd_recovery_start = 0; obd->obd_recovery_end = 0; - cfs_timer_init(&obd->obd_recovery_timer, target_recovery_expired, obd); - target_start_recovery_thread(lut, handler); + setup_timer(&obd->obd_recovery_timer, target_recovery_expired, + (unsigned long)obd); + target_start_recovery_thread(lut, handler); } EXPORT_SYMBOL(target_recovery_init); @@ -3149,8 +3184,7 @@ int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc, if (req->rq_bulk_read) rc = sptlrpc_svc_wrap_bulk(req, desc); - if ((exp->exp_connect_data.ocd_connect_flags & - OBD_CONNECT_BULK_MBITS) != 0) + if (OCD_HAS_FLAG(&exp->exp_connect_data, BULK_MBITS)) req->rq_mbits = lustre_msg_get_mbits(req->rq_reqmsg); else /* old version, bulk matchbits is rq_xid */ req->rq_mbits = req->rq_xid;