* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2011, 2016, Intel Corporation.
+ * Copyright (c) 2011, 2017, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
imp->imp_state = state;
imp->imp_state_hist[imp->imp_state_hist_idx].ish_state = state;
imp->imp_state_hist[imp->imp_state_hist_idx].ish_time =
- cfs_time_current_sec();
+ ktime_get_real_seconds();
imp->imp_state_hist_idx = (imp->imp_state_hist_idx + 1) %
IMP_STATE_HIST_LEN;
}
"lost; in progress operations using this "
"service will wait for recovery to complete\n",
imp->imp_obd->obd_name, target_len, target_start,
- libcfs_nid2str(imp->imp_connection->c_peer.nid));
- } else {
- LCONSOLE_ERROR_MSG(0x166, "%s: Connection to "
- "%.*s (at %s) was lost; in progress "
- "operations using this service will fail\n",
- imp->imp_obd->obd_name,
- target_len, target_start,
- libcfs_nid2str(imp->imp_connection->c_peer.nid));
- }
- IMPORT_SET_STATE_NOLOCK(imp, LUSTRE_IMP_DISCON);
+ obd_import_nid2str(imp));
+ } else {
+ LCONSOLE_ERROR_MSG(0x166, "%s: Connection to "
+ "%.*s (at %s) was lost; in progress "
+ "operations using this service will fail\n",
+ imp->imp_obd->obd_name, target_len, target_start,
+ obd_import_nid2str(imp));
+ }
+ IMPORT_SET_STATE_NOLOCK(imp, LUSTRE_IMP_DISCON);
spin_unlock(&imp->imp_lock);
if (obd_dump_on_timeout)
}
EXPORT_SYMBOL(ptlrpc_deactivate_import);
-static unsigned int
-ptlrpc_inflight_deadline(struct ptlrpc_request *req, time_t now)
+static time64_t ptlrpc_inflight_deadline(struct ptlrpc_request *req,
+ time64_t now)
{
- long dl;
+ time64_t dl;
if (!(((req->rq_phase == RQ_PHASE_RPC) && !req->rq_waiting) ||
(req->rq_phase == RQ_PHASE_BULK) ||
static unsigned int ptlrpc_inflight_timeout(struct obd_import *imp)
{
- time_t now = cfs_time_current_sec();
+ time64_t now = ktime_get_real_seconds();
struct list_head *tmp, *n;
struct ptlrpc_request *req;
- unsigned int timeout = 0;
+ time64_t timeout = 0;
spin_lock(&imp->imp_lock);
list_for_each_safe(tmp, n, &imp->imp_sending_list) {
struct list_head *tmp, *n;
struct ptlrpc_request *req;
struct l_wait_info lwi;
- unsigned int timeout;
+ time64_t timeout;
int rc;
atomic_inc(&imp->imp_inval_count);
* unlink. We can't do anything before that because there is really
* no guarantee that some rdma transfer is not in progress right now. */
do {
+ long timeout_jiffies;
+
/* Calculate max timeout for waiting on rpcs to error
* out. Use obd_timeout if calculated value is smaller
- * than it. */
+ * than it.
+ */
if (!OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_REPL_UNLINK)) {
timeout = ptlrpc_inflight_timeout(imp);
timeout += timeout / 3;
timeout = 1;
}
- CDEBUG(D_RPCTRACE,"Sleeping %d sec for inflight to error out\n",
- timeout);
+ CDEBUG(D_RPCTRACE, "Sleeping %llds for inflight to error out\n",
+ timeout);
/* Wait for all requests to error out and call completion
* callbacks. Cap it at obd_timeout -- these should all
- * have been locally cancelled by ptlrpc_abort_inflight. */
- lwi = LWI_TIMEOUT_INTERVAL(
- cfs_timeout_cap(cfs_time_seconds(timeout)),
- (timeout > 1)?cfs_time_seconds(1):cfs_time_seconds(1)/2,
- NULL, NULL);
+ * have been locally cancelled by ptlrpc_abort_inflight.
+ */
+ timeout_jiffies = max_t(long, cfs_time_seconds(timeout), 1);
+ lwi = LWI_TIMEOUT_INTERVAL(timeout_jiffies,
+ (timeout > 1) ? cfs_time_seconds(1) :
+ cfs_time_seconds(1) / 2,
+ NULL, NULL);
rc = l_wait_event(imp->imp_recovery_waitq,
(atomic_read(&imp->imp_inflight) == 0),
&lwi);
int ptlrpc_reconnect_import(struct obd_import *imp)
{
#ifdef ENABLE_PINGER
+ long timeout_jiffies = cfs_time_seconds(obd_timeout);
struct l_wait_info lwi;
- int secs = cfs_time_seconds(obd_timeout);
int rc;
ptlrpc_pinger_force(imp);
CDEBUG(D_HA, "%s: recovery started, waiting %u seconds\n",
- obd2cli_tgt(imp->imp_obd), secs);
+ obd2cli_tgt(imp->imp_obd), obd_timeout);
- lwi = LWI_TIMEOUT(secs, NULL, NULL);
+ lwi = LWI_TIMEOUT(timeout_jiffies, NULL, NULL);
rc = l_wait_event(imp->imp_recovery_waitq,
!ptlrpc_import_in_recovery(imp), &lwi);
CDEBUG(D_HA, "%s: recovery finished s:%s\n", obd2cli_tgt(imp->imp_obd),
}
list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
- CDEBUG(D_HA, "%s: connect to NID %s last attempt %llu\n",
+ CDEBUG(D_HA, "%s: connect to NID %s last attempt %lld\n",
imp->imp_obd->obd_name,
libcfs_nid2str(conn->oic_conn->c_peer.nid),
conn->oic_last_attempt);
/* If we have not tried this connection since
the last successful attempt, go with this one */
if ((conn->oic_last_attempt == 0) ||
- cfs_time_beforeq_64(conn->oic_last_attempt,
- imp->imp_last_success_conn)) {
+ conn->oic_last_attempt <= imp->imp_last_success_conn) {
imp_conn = conn;
tried_all = 0;
break;
least recently used */
if (!imp_conn)
imp_conn = conn;
- else if (cfs_time_before_64(conn->oic_last_attempt,
- imp_conn->oic_last_attempt))
+ else if (imp_conn->oic_last_attempt > conn->oic_last_attempt)
imp_conn = conn;
}
"to %ds\n", imp->imp_obd->obd_name, at_get(at));
}
- imp_conn->oic_last_attempt = cfs_time_current_64();
+ imp_conn->oic_last_attempt = ktime_get_seconds();
/* switch connection, don't mind if it's same as the current one */
if (imp->imp_connection)
lustre_msg_add_op_flags(request->rq_reqmsg,
MSG_CONNECT_TRANSNO);
- DEBUG_REQ(D_RPCTRACE, request, "(re)connect request (timeout %d)",
+ DEBUG_REQ(D_RPCTRACE, request, "(re)connect request (timeout %ld)",
request->rq_timeout);
ptlrpcd_add_req(request);
rc = 0;
static bool warned;
struct client_obd *cli = &imp->imp_obd->u.cli;
- if ((imp->imp_connect_flags_orig & OBD_CONNECT_IBITS) &&
- !(ocd->ocd_connect_flags & OBD_CONNECT_IBITS)) {
- LCONSOLE_WARN("%s: MDS %s does not support ibits "
- "lock, either very old or invalid: "
- "requested %#llx, replied %#llx\n",
- imp->imp_obd->obd_name,
- imp->imp_connection->c_remote_uuid.uuid,
- imp->imp_connect_flags_orig,
- ocd->ocd_connect_flags);
- return -EPROTO;
- }
-
spin_lock(&imp->imp_lock);
list_del(&imp->imp_conn_current->oic_item);
list_add(&imp->imp_conn_current->oic_item,
spin_unlock(&imp->imp_lock);
-
if (!warned && (ocd->ocd_connect_flags & OBD_CONNECT_VERSION) &&
(ocd->ocd_version > LUSTRE_VERSION_CODE +
LUSTRE_VERSION_OFFSET_WARN ||
const char *older = "older than client. "
"Consider upgrading server";
const char *newer = "newer than client. "
- "Consider recompiling application";
+ "Consider upgrading client";
LCONSOLE_WARN("Server %s version (%d.%d.%d.%d) "
"is much %s (%s)\n",
warned = true;
}
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0)
- /* Check if server has LU-1252 fix applied to not always swab
- * the IR MNE entries. Do this only once per connection. This
- * fixup is version-limited, because we don't want to carry the
- * OBD_CONNECT_MNE_SWAB flag around forever, just so long as we
- * need interop with unpatched 2.2 servers. For newer servers,
- * the client will do MNE swabbing only as needed. LU-1644 */
- if (unlikely((ocd->ocd_connect_flags & OBD_CONNECT_VERSION) &&
- !(ocd->ocd_connect_flags & OBD_CONNECT_MNE_SWAB) &&
- OBD_OCD_VERSION_MAJOR(ocd->ocd_version) == 2 &&
- OBD_OCD_VERSION_MINOR(ocd->ocd_version) == 2 &&
- OBD_OCD_VERSION_PATCH(ocd->ocd_version) < 55 &&
- strcmp(imp->imp_obd->obd_type->typ_name,
- LUSTRE_MGC_NAME) == 0))
- imp->imp_need_mne_swab = 1;
- else /* clear if server was upgraded since last connect */
- imp->imp_need_mne_swab = 0;
-#endif
-
if (ocd->ocd_connect_flags & OBD_CONNECT_CKSUM) {
/* We sent to the server ocd_cksum_types with bits set
* for algorithms we understand. The server masked off
* the checksum types it doesn't support */
if ((ocd->ocd_cksum_types &
cksum_types_supported_client()) == 0) {
- LCONSOLE_WARN("The negotiation of the checksum "
- "alogrithm to use with server %s "
- "failed (%x/%x), disabling "
- "checksums\n",
- obd2cli_tgt(imp->imp_obd),
- ocd->ocd_cksum_types,
- cksum_types_supported_client());
- cli->cl_checksum = 0;
- cli->cl_supp_cksum_types = OBD_CKSUM_ADLER;
+ LCONSOLE_ERROR("The negotiation of the checksum "
+ "alogrithm to use with server %s "
+ "failed (%x/%x)\n",
+ obd2cli_tgt(imp->imp_obd),
+ ocd->ocd_cksum_types,
+ cksum_types_supported_client());
+ return -EPROTO;
} else {
cli->cl_supp_cksum_types = ocd->ocd_cksum_types;
}
__u64 old_connect_flags;
int msg_flags;
struct obd_connect_data *ocd;
- struct obd_export *exp;
+ struct obd_export *exp = NULL;
int ret;
ENTRY;
/* Import flags should be updated before waking import at FULL state */
rc = ptlrpc_connect_set_flags(imp, ocd, old_connect_flags, exp,
- aa->pcaa_initial_connect);
+ aa->pcaa_initial_connect);
class_export_put(exp);
+ exp = NULL;
+
if (rc != 0)
GOTO(out, rc);
imp->imp_connect_tried = 1;
spin_unlock(&imp->imp_lock);
+ if (exp != NULL)
+ class_export_put(exp);
+
if (rc != 0) {
IMPORT_SET_STATE(imp, LUSTRE_IMP_DISCON);
if (rc == -EACCES) {
if (request->rq_repmsg == NULL)
RETURN(-EPROTO);
- ocd = req_capsule_server_get(&request->rq_pill,
- &RMF_CONNECT_DATA);
- if (ocd &&
- (ocd->ocd_connect_flags & OBD_CONNECT_VERSION) &&
- (ocd->ocd_version != LUSTRE_VERSION_CODE)) {
- /* Actually servers are only supposed to refuse
- connection from liblustre clients, so we should
- never see this from VFS context */
+ ocd = req_capsule_server_get(&request->rq_pill,
+ &RMF_CONNECT_DATA);
+ /* Servers are not supposed to refuse connections from
+ * clients based on version, only connection feature
+ * flags. We should never see this from llite, but it
+ * may be useful for debugging in the future. */
+ if (ocd &&
+ (ocd->ocd_connect_flags & OBD_CONNECT_VERSION) &&
+ (ocd->ocd_version != LUSTRE_VERSION_CODE)) {
LCONSOLE_ERROR_MSG(0x16a, "Server %s version "
"(%d.%d.%d.%d)"
" refused connection from this client "
LCONSOLE_INFO("%s: Connection restored to %s (at %s)\n",
imp->imp_obd->obd_name,
obd_uuid2str(&conn->c_remote_uuid),
- libcfs_nid2str(imp->imp_connection->c_peer.nid));
+ obd_import_nid2str(imp));
}
if (imp->imp_state == LUSTRE_IMP_FULL) {
RETURN(rc);
}
- if (ptlrpc_import_in_recovery(imp)) {
- struct l_wait_info lwi;
- cfs_duration_t timeout;
+ if (ptlrpc_import_in_recovery(imp)) {
+ struct l_wait_info lwi;
+ long timeout_jiffies;
+ time64_t timeout;
- if (AT_OFF) {
- if (imp->imp_server_timeout)
- timeout = cfs_time_seconds(obd_timeout / 2);
- else
- timeout = cfs_time_seconds(obd_timeout);
- } else {
- int idx = import_at_get_index(imp,
- imp->imp_client->cli_request_portal);
- timeout = cfs_time_seconds(
- at_get(&imp->imp_at.iat_service_estimate[idx]));
+ if (AT_OFF) {
+ if (imp->imp_server_timeout)
+ timeout = obd_timeout >> 1;
+ else
+ timeout = obd_timeout;
+ } else {
+ u32 req_portal;
+ int idx;
+
+ req_portal = imp->imp_client->cli_request_portal;
+ idx = import_at_get_index(imp, req_portal);
+ timeout = at_get(&imp->imp_at.iat_service_estimate[idx]);
}
- lwi = LWI_TIMEOUT_INTR(cfs_timeout_cap(timeout),
+ timeout_jiffies = cfs_time_seconds(timeout);
+ lwi = LWI_TIMEOUT_INTR(max_t(long, timeout_jiffies, 1),
back_to_sleep, LWI_ON_SIGNAL_NOOP, NULL);
rc = l_wait_event(imp->imp_recovery_waitq,
!ptlrpc_import_in_recovery(imp), &lwi);