/*
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
- */
-/*
- * Copyright (c) 2011 Whamcloud, Inc.
+ *
+ * Copyright (c) 2011, 2012, Whamcloud, Inc.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
RETURN(rc);
}
+/**
+ * Find conn uuid by peer nid. @peer is a server nid. This function is used
+ * to find a conn uuid of @imp which can reach @peer.
+ */
+int client_import_find_conn(struct obd_import *imp, lnet_nid_t peer,
+ struct obd_uuid *uuid)
+{
+ struct obd_import_conn *conn;
+ int rc = -ENOENT;
+ ENTRY;
+
+ cfs_spin_lock(&imp->imp_lock);
+ cfs_list_for_each_entry(conn, &imp->imp_conn_list, oic_item) {
+ /* check if conn uuid does have this peer nid */
+ if (class_check_uuid(&conn->oic_uuid, peer)) {
+ *uuid = conn->oic_uuid;
+ rc = 0;
+ break;
+ }
+ }
+ cfs_spin_unlock(&imp->imp_lock);
+ RETURN(rc);
+}
+EXPORT_SYMBOL(client_import_find_conn);
+
void client_destroy_import(struct obd_import *imp)
{
/* drop security policy instance after all rpc finished/aborted
sptlrpc_import_sec_put(imp);
class_import_put(imp);
}
+EXPORT_SYMBOL(client_destroy_import);
/* configure an RPC client OBD device
*
ldlm_namespace_free_post(obddev->obd_namespace);
obddev->obd_namespace = NULL;
+ LASSERT(obddev->u.cli.cl_import == NULL);
+
ldlm_put_ref();
RETURN(0);
}
imp->imp_connect_flags_orig = data->ocd_connect_flags;
}
- rc = ptlrpc_connect_import(imp, NULL);
+ rc = ptlrpc_connect_import(imp);
if (rc != 0) {
LASSERT (imp->imp_state == LUSTRE_IMP_DISCON);
GOTO(out_ldlm, rc);
ptlrpc_invalidate_import(imp);
- if (imp->imp_rq_pool) {
- ptlrpc_free_rq_pool(imp->imp_rq_pool);
- imp->imp_rq_pool = NULL;
- }
- client_destroy_import(imp);
- cli->cl_import = NULL;
-
EXIT;
out_disconnect:
struct obd_uuid *cluuid)
{
ENTRY;
+
if (exp->exp_connection && exp->exp_imp_reverse) {
struct lustre_handle *hdl;
+ struct obd_device *target;
+
hdl = &exp->exp_imp_reverse->imp_remote_handle;
+ target = exp->exp_obd;
+
/* Might be a re-connect after a partition. */
if (!memcmp(&conn->cookie, &hdl->cookie, sizeof conn->cookie)) {
- CWARN("%s: %s reconnecting\n", exp->exp_obd->obd_name,
- cluuid->uuid);
+ if (target->obd_recovering)
+ LCONSOLE_WARN("%s: Client %s (at %s) reconnect"
+ "ing, waiting for %d clients in "
+ "recovery for %lds\n", target->obd_name,
+ obd_uuid2str(&exp->exp_client_uuid),
+ obd_export_nid2str(exp),
+ target->obd_max_recoverable_clients,
+ cfs_duration_sec(cfs_time_sub(
+ cfs_timer_deadline(
+ &target->obd_recovery_timer),
+ cfs_time_current())));
+ else
+ LCONSOLE_WARN("%s: Client %s (at %s) "
+ "reconnecting\n", target->obd_name,
+ obd_uuid2str(&exp->exp_client_uuid),
+ obd_export_nid2str(exp));
+
conn->cookie = exp->exp_handle.h_cookie;
/* target_handle_connect() treats EALREADY and
* -EALREADY differently. EALREADY means we are
* doing a valid reconnect from the same client. */
RETURN(EALREADY);
} else {
- CERROR("%s reconnecting from %s, "
- "handle mismatch (ours "LPX64", theirs "
- LPX64")\n", cluuid->uuid,
- exp->exp_connection->c_remote_uuid.uuid,
- hdl->cookie, conn->cookie);
+ LCONSOLE_WARN("%s: The server has already connected "
+ "client %s (at %s) with handle " LPX64
+ ", rejecting a client with the same "
+ "uuid trying to reconnect with "
+ "handle " LPX64, target->obd_name,
+ obd_uuid2str(&exp->exp_client_uuid),
+ obd_export_nid2str(exp),
+ hdl->cookie, conn->cookie);
memset(conn, 0, sizeof *conn);
/* target_handle_connect() treats EALREADY and
* -EALREADY differently. -EALREADY is an error
}
EXPORT_SYMBOL(target_client_add_cb);
+#ifdef __KERNEL__
static void
-target_start_and_reset_recovery_timer(struct obd_device *obd,
- struct ptlrpc_request *req,
- int new_client);
+check_and_start_recovery_timer(struct obd_device *obd,
+ struct ptlrpc_request *req, int new_client);
+#else
+static inline void
+check_and_start_recovery_timer(struct obd_device *obd,
+ struct ptlrpc_request *req, int new_client)
+{
+}
+#endif
int target_handle_connect(struct ptlrpc_request *req)
{
struct obd_uuid remote_uuid;
char *str;
int rc = 0;
+ char *target_start;
+ int target_len;
int mds_conn = 0;
struct obd_connect_data *data, *tmpdata;
int size, tmpsize;
target = class_name2obd(str);
if (!target || target->obd_stopping || !target->obd_set_up) {
- LCONSOLE_ERROR_MSG(0x137, "UUID '%s' is not available "
- " for connect (%s)\n", str,
- !target ? "no target" :
- (target->obd_stopping ? "stopping" :
- "not set up"));
+ deuuidify(str, NULL, &target_start, &target_len);
+ LCONSOLE_ERROR_MSG(0x137, "%.*s: Not available for connect "
+ "from %s (%s)\n", target_len, target_start,
+ libcfs_nid2str(req->rq_peer.nid), !target ?
+ "no target" : (target->obd_stopping ?
+ "stopping" : "not set up"));
GOTO(out, rc = -ENODEV);
}
if (target->obd_no_conn) {
- LCONSOLE_WARN("%s: temporarily refusing client connection "
+ LCONSOLE_WARN("%s: Temporarily refusing client connection "
"from %s\n", target->obd_name,
libcfs_nid2str(req->rq_peer.nid));
GOTO(out, rc = -EAGAIN);
/* we've found an export in the hash */
if (export->exp_connecting) { /* bug 9635, et. al. */
- CWARN("%s: exp %p already connecting\n",
- export->exp_obd->obd_name, export);
+ LCONSOLE_WARN("%s: Export %p already connecting from %s\n",
+ export->exp_obd->obd_name, export,
+ libcfs_nid2str(req->rq_peer.nid));
class_export_put(export);
export = NULL;
rc = -EALREADY;
} else if (mds_conn && export->exp_connection) {
if (req->rq_peer.nid != export->exp_connection->c_peer.nid)
/* mds reconnected after failover */
- CWARN("%s: received MDS connection from NID %s,"
- " removing former export from NID %s\n",
+ LCONSOLE_WARN("%s: Received MDS connection from "
+ "%s, removing former export from %s\n",
target->obd_name, libcfs_nid2str(req->rq_peer.nid),
libcfs_nid2str(export->exp_connection->c_peer.nid));
else
/* new mds connection from the same nid */
- CWARN("%s: received new MDS connection from NID %s,"
- " removing former export from same NID\n",
+ LCONSOLE_WARN("%s: Received new MDS connection from "
+ "%s, removing former export from same NID\n",
target->obd_name, libcfs_nid2str(req->rq_peer.nid));
class_fail_export(export);
class_export_put(export);
MSG_CONNECT_INITIAL)) {
/* in mds failover we have static uuid but nid can be
* changed*/
- CWARN("%s: cookie %s seen on new NID %s when "
- "existing NID %s is already connected\n",
- target->obd_name, cluuid.uuid,
- libcfs_nid2str(req->rq_peer.nid),
- libcfs_nid2str(export->exp_connection->c_peer.nid));
+ LCONSOLE_WARN("%s: Client %s seen on new nid %s when "
+ "existing nid %s is already connected\n",
+ target->obd_name, cluuid.uuid,
+ libcfs_nid2str(req->rq_peer.nid),
+ libcfs_nid2str(
+ export->exp_connection->c_peer.nid));
rc = -EALREADY;
class_export_put(export);
export = NULL;
cfs_spin_lock(&export->exp_lock);
export->exp_connecting = 1;
cfs_spin_unlock(&export->exp_lock);
- class_export_put(export);
LASSERT(export->exp_obd == target);
rc = target_handle_reconnect(&conn, export, &cluuid);
OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_CONNECT, 2 * obd_timeout);
} else if (req->rq_export == NULL &&
cfs_atomic_read(&export->exp_rpc_count) > 0) {
- CWARN("%s: refuse connection from %s/%s to 0x%p/%d\n",
- target->obd_name, cluuid.uuid,
- libcfs_nid2str(req->rq_peer.nid),
- export, cfs_atomic_read(&export->exp_refcount));
+ LCONSOLE_WARN("%s: Client %s (at %s) refused connection, "
+ "still busy with %d references\n",
+ target->obd_name, cluuid.uuid,
+ libcfs_nid2str(req->rq_peer.nid),
+ cfs_atomic_read(&export->exp_refcount));
GOTO(out, rc = -EBUSY);
} else if (req->rq_export != NULL &&
(cfs_atomic_read(&export->exp_rpc_count) > 1)) {
/* the current connect rpc has increased exp_rpc_count */
- CWARN("%s: refuse reconnection from %s@%s to 0x%p/%d\n",
- target->obd_name, cluuid.uuid,
- libcfs_nid2str(req->rq_peer.nid),
- export, cfs_atomic_read(&export->exp_rpc_count) - 1);
+ LCONSOLE_WARN("%s: Client %s (at %s) refused reconnection, "
+ "still busy with %d active RPCs\n",
+ target->obd_name, cluuid.uuid,
+ libcfs_nid2str(req->rq_peer.nid),
+ cfs_atomic_read(&export->exp_rpc_count) - 1);
cfs_spin_lock(&export->exp_lock);
if (req->rq_export->exp_conn_cnt <
lustre_msg_get_conn_cnt(req->rq_reqmsg))
cfs_spin_unlock(&export->exp_lock);
GOTO(out, rc = -EBUSY);
} else if (lustre_msg_get_conn_cnt(req->rq_reqmsg) == 1) {
- CERROR("%s: NID %s (%s) reconnected with 1 conn_cnt; "
- "cookies not random?\n", target->obd_name,
- libcfs_nid2str(req->rq_peer.nid), cluuid.uuid);
+ if (!strstr(cluuid.uuid, "mdt"))
+ LCONSOLE_WARN("%s: Rejecting reconnect from the "
+ "known client %s (at %s) because it "
+ "is indicating it is a new client",
+ target->obd_name, cluuid.uuid,
+ libcfs_nid2str(req->rq_peer.nid));
GOTO(out, rc = -EALREADY);
} else {
OBD_FAIL_TIMEOUT(OBD_FAIL_TGT_DELAY_RECONNECT, 2 * obd_timeout);
GOTO(out, rc);
}
- CWARN("%s: connection from %s@%s %st"LPU64" exp %p cur %ld last %ld\n",
+ CDEBUG(D_HA, "%s: connection from %s@%s %st"LPU64" exp %p cur %ld last %ld\n",
target->obd_name, cluuid.uuid, libcfs_nid2str(req->rq_peer.nid),
target->obd_recovering ? "recovering/" : "", data->ocd_transno,
export, (long)cfs_time_current_sec(),
export ? (long)export->exp_last_request_time : 0);
- /* If this is the first time a client connects,
- * reset the recovery timer */
+ /* If this is the first time a client connects, reset the recovery
+ * timer */
if (rc == 0 && target->obd_recovering)
- target_start_and_reset_recovery_timer(target, req, !export);
+ check_and_start_recovery_timer(target, req, export == NULL);
/* We want to handle EALREADY but *not* -EALREADY from
* target_handle_reconnect(), return reconnection state in a flag */
t = cfs_timer_deadline(&target->obd_recovery_timer);
t = cfs_time_sub(t, cfs_time_current());
- CERROR("%s: denying connection for new client %s (%s): "
- "%d clients in recovery for "CFS_TIME_T"s\n",
- target->obd_name,
- libcfs_nid2str(req->rq_peer.nid), cluuid.uuid,
- cfs_atomic_read(&target-> \
- obd_lock_replay_clients),
- cfs_duration_sec(t));
+ LCONSOLE_WARN("%s: Denying connection for new client "
+ "%s (at %s), waiting for %d clients in "
+ "recovery for "CFS_TIME_T"s\n",
+ target->obd_name,
+ libcfs_nid2str(req->rq_peer.nid),
+ cluuid.uuid,
+ cfs_atomic_read(&target-> \
+ obd_lock_replay_clients),
+ cfs_duration_sec(t));
rc = -EBUSY;
} else {
dont_check_exports:
rc = obd_connect(req->rq_svc_thread->t_env,
&export, target, &cluuid, data,
client_nid);
- if (rc == 0)
+ if (rc == 0) {
conn.cookie = export->exp_handle.h_cookie;
+ /* LU-1092 reconnect put export refcount in the
+ * end, connect needs take one here too. */
+ class_export_get(export);
+ }
}
} else {
rc = obd_reconnect(req->rq_svc_thread->t_env,
}
if (rc)
GOTO(out, rc);
+
+ LASSERT(target->u.obt.obt_magic == OBT_MAGIC);
+ data->ocd_instance = target->u.obt.obt_instance;
+
/* Return only the parts of obd_connect_data that we understand, so the
* client knows that we don't understand the rest. */
if (data) {
cfs_spin_lock(&export->exp_lock);
if (export->exp_conn_cnt >= lustre_msg_get_conn_cnt(req->rq_reqmsg)) {
cfs_spin_unlock(&export->exp_lock);
- CERROR("%s: %s already connected at higher conn_cnt: %d > %d\n",
+ CDEBUG(D_RPCTRACE, "%s: %s already connected at higher "
+ "conn_cnt: %d > %d\n",
cluuid.uuid, libcfs_nid2str(req->rq_peer.nid),
export->exp_conn_cnt,
lustre_msg_get_conn_cnt(req->rq_reqmsg));
&export->exp_connection->c_peer.nid,
&export->exp_nid_hash);
}
-
- cfs_spin_lock(&target->obd_recovery_task_lock);
+ /**
+ class_disconnect->class_export_recovery_cleanup() race
+ */
if (target->obd_recovering && !export->exp_in_recovery) {
+ int has_transno;
+ __u64 transno = data->ocd_transno;
+
cfs_spin_lock(&export->exp_lock);
export->exp_in_recovery = 1;
export->exp_req_replay_needed = 1;
export->exp_lock_replay_needed = 1;
cfs_spin_unlock(&export->exp_lock);
- if ((lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_TRANSNO)
- && (data->ocd_transno == 0))
+
+ has_transno = !!(lustre_msg_get_op_flags(req->rq_reqmsg) &
+ MSG_CONNECT_TRANSNO);
+ if (has_transno && transno == 0)
CWARN("Connect with zero transno!\n");
- if ((lustre_msg_get_op_flags(req->rq_reqmsg) & MSG_CONNECT_TRANSNO)
- && data->ocd_transno < target->obd_next_recovery_transno &&
- data->ocd_transno > target->obd_last_committed)
- target->obd_next_recovery_transno = data->ocd_transno;
- target->obd_connected_clients++;
+ if (has_transno && transno > 0 &&
+ transno < target->obd_next_recovery_transno &&
+ transno > target->obd_last_committed) {
+ /* another way is to use cmpxchg() so it will be
+ * lock free */
+ cfs_spin_lock(&target->obd_recovery_task_lock);
+ if (transno < target->obd_next_recovery_transno)
+ target->obd_next_recovery_transno = transno;
+ cfs_spin_unlock(&target->obd_recovery_task_lock);
+ }
+
cfs_atomic_inc(&target->obd_req_replay_clients);
cfs_atomic_inc(&target->obd_lock_replay_clients);
- if (target->obd_connected_clients ==
+ if (cfs_atomic_inc_return(&target->obd_connected_clients) ==
target->obd_max_recoverable_clients)
cfs_waitq_signal(&target->obd_next_transno_waitq);
}
- cfs_spin_unlock(&target->obd_recovery_task_lock);
/* Tell the client we're in recovery, when client is involved in it. */
if (target->obd_recovering)
cfs_spin_lock(&export->exp_lock);
export->exp_connecting = 0;
cfs_spin_unlock(&export->exp_lock);
+
+ class_export_put(export);
}
if (targref)
class_decref(targref, __FUNCTION__, cfs_current());
#ifdef __KERNEL__
static void target_finish_recovery(struct obd_device *obd)
{
+ time_t elapsed_time = max_t(time_t, 1, cfs_time_current_sec() -
+ obd->obd_recovery_start);
ENTRY;
- LCONSOLE_INFO("%s: sending delayed replies to recovered clients\n",
- obd->obd_name);
+
+ LCONSOLE_INFO("%s: Recovery over after %d:%.02d, of %d clients "
+ "%d recovered and %d %s evicted.\n", obd->obd_name,
+ (int)elapsed_time / 60, (int)elapsed_time % 60,
+ obd->obd_max_recoverable_clients,
+ cfs_atomic_read(&obd->obd_connected_clients),
+ obd->obd_stale_clients,
+ obd->obd_stale_clients == 1 ? "was" : "were");
ldlm_reprocess_all_ns(obd->obd_namespace);
cfs_spin_lock(&obd->obd_recovery_task_lock);
target_request_copy_put(req);
}
}
-#endif
/* Called from a cleanup function if the device is being cleaned up
forcefully. The exports should all have been disconnected already,
cfs_timer_disarm(&obd->obd_recovery_timer);
}
-/* extend = 1 means require at least "duration" seconds left in the timer,
- extend = 0 means set the total duration (start_recovery_timer) */
-static void reset_recovery_timer(struct obd_device *obd, int duration,
- int extend)
+static void target_start_recovery_timer(struct obd_device *obd)
{
- cfs_time_t now = cfs_time_current_sec();
- cfs_duration_t left;
+ if (obd->obd_recovery_start != 0)
+ return;
- cfs_spin_lock(&obd->obd_recovery_task_lock);
+ cfs_spin_lock(&obd->obd_dev_lock);
if (!obd->obd_recovering || obd->obd_abort_recovery) {
- cfs_spin_unlock(&obd->obd_recovery_task_lock);
+ cfs_spin_unlock(&obd->obd_dev_lock);
return;
}
- left = cfs_time_sub(obd->obd_recovery_end, now);
+ LASSERT(obd->obd_recovery_timeout != 0);
- if (extend && (duration > left))
- obd->obd_recovery_timeout += duration - left;
- else if (!extend && (duration > obd->obd_recovery_timeout))
- /* Track the client's largest expected replay time */
- obd->obd_recovery_timeout = duration;
+ if (obd->obd_recovery_start != 0) {
+ cfs_spin_unlock(&obd->obd_dev_lock);
+ return;
+ }
- /* Hard limit of obd_recovery_time_hard which should not happen */
- if (obd->obd_recovery_timeout > obd->obd_recovery_time_hard)
- obd->obd_recovery_timeout = obd->obd_recovery_time_hard;
+ cfs_timer_arm(&obd->obd_recovery_timer,
+ cfs_time_shift(obd->obd_recovery_timeout));
+ obd->obd_recovery_start = cfs_time_current_sec();
+ cfs_spin_unlock(&obd->obd_dev_lock);
- obd->obd_recovery_end = obd->obd_recovery_start +
- obd->obd_recovery_timeout;
- if (!cfs_timer_is_armed(&obd->obd_recovery_timer) ||
- cfs_time_before(now, obd->obd_recovery_end)) {
- left = cfs_time_sub(obd->obd_recovery_end, now);
- cfs_timer_arm(&obd->obd_recovery_timer, cfs_time_shift(left));
- }
- cfs_spin_unlock(&obd->obd_recovery_task_lock);
- CDEBUG(D_HA, "%s: recovery timer will expire in %u seconds\n",
- obd->obd_name, (unsigned)left);
+ 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": "");
}
-static void check_and_start_recovery_timer(struct obd_device *obd)
+/**
+ * extend recovery window.
+ *
+ * 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)
{
- cfs_spin_lock(&obd->obd_recovery_task_lock);
- if (cfs_timer_is_armed(&obd->obd_recovery_timer)) {
- cfs_spin_unlock(&obd->obd_recovery_task_lock);
+ cfs_time_t now;
+ cfs_time_t end;
+ cfs_duration_t left;
+ int to;
+
+ cfs_spin_lock(&obd->obd_dev_lock);
+ if (!obd->obd_recovering || obd->obd_abort_recovery) {
+ cfs_spin_unlock(&obd->obd_dev_lock);
return;
}
- CDEBUG(D_HA, "%s: starting recovery timer\n", obd->obd_name);
- obd->obd_recovery_start = cfs_time_current_sec();
- cfs_spin_unlock(&obd->obd_recovery_task_lock);
+ 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);
+
+ if (extend && (drt > left)) {
+ to += drt - left;
+ } else if (!extend && (drt > to)) {
+ to = drt;
+ /* reduce drt by already passed time */
+ drt -= obd->obd_recovery_timeout - left;
+ }
+
+ if (to > obd->obd_recovery_time_hard)
+ to = obd->obd_recovery_time_hard;
+ if (obd->obd_recovery_timeout < to) {
+ obd->obd_recovery_timeout = to;
+ cfs_timer_arm(&obd->obd_recovery_timer,
+ cfs_time_shift(drt));
+ }
+ cfs_spin_unlock(&obd->obd_dev_lock);
- reset_recovery_timer(obd, obd->obd_recovery_timeout, 0);
+ CDEBUG(D_HA, "%s: recovery timer will expire in %u seconds\n",
+ obd->obd_name, (unsigned)drt);
}
/* Reset the timer with each new client connection */
*/
static void
-target_start_and_reset_recovery_timer(struct obd_device *obd,
- struct ptlrpc_request *req,
- int new_client)
+check_and_start_recovery_timer(struct obd_device *obd,
+ struct ptlrpc_request *req,
+ int new_client)
{
int service_time = lustre_msg_get_service_time(req->rq_reqmsg);
+ struct obd_device_target *obt = &obd->u.obt;
+ struct lustre_sb_info *lsi;
if (!new_client && service_time)
/* Teach server about old server's estimates, as first guess
at_measured(&req->rq_rqbd->rqbd_service->srv_at_estimate,
service_time);
- check_and_start_recovery_timer(obd);
+ target_start_recovery_timer(obd);
/* convert the service time to rpc timeout,
* reuse service_time to limit stack usage */
/* 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 */
- service_time += 2 * (CONNECTION_SWITCH_MAX + CONNECTION_SWITCH_INC +
- INITIAL_CONNECT_TIMEOUT);
+ service_time += 2 * INITIAL_CONNECT_TIMEOUT;
+
+ LASSERT(obt->obt_magic == OBT_MAGIC);
+ lsi = s2lsi(obt->obt_sb);
+ if (!(lsi->lsi_flags | LSI_IR_CAPABLE))
+ service_time += 2 * (CONNECTION_SWITCH_MAX +
+ CONNECTION_SWITCH_INC);
if (service_time > obd->obd_recovery_timeout && !new_client)
- reset_recovery_timer(obd, service_time, 0);
+ extend_recovery_timer(obd, service_time, false);
}
-#ifdef __KERNEL__
-
/** Health checking routines */
static inline int exp_connect_healthy(struct obd_export *exp)
{
/** Checking routines for recovery */
static int check_for_clients(struct obd_device *obd)
{
+ unsigned int clnts = cfs_atomic_read(&obd->obd_connected_clients);
+
if (obd->obd_abort_recovery || obd->obd_recovery_expired)
return 1;
- LASSERT(obd->obd_connected_clients <= obd->obd_max_recoverable_clients);
+ LASSERT(clnts <= obd->obd_max_recoverable_clients);
if (obd->obd_no_conn == 0 &&
- obd->obd_connected_clients + obd->obd_stale_clients ==
- obd->obd_max_recoverable_clients)
+ clnts + obd->obd_stale_clients == obd->obd_max_recoverable_clients)
return 1;
return 0;
}
req_transno = 0;
}
- connected = obd->obd_connected_clients;
+ connected = cfs_atomic_read(&obd->obd_connected_clients);
completed = connected - cfs_atomic_read(&obd->obd_req_replay_clients);
queue_len = obd->obd_requests_queued_for_recovery;
next_transno = obd->obd_next_recovery_transno;
* reset timer, recovery will proceed with versions now,
* timeout is set just to handle reconnection delays
*/
- reset_recovery_timer(obd, RECONNECT_DELAY_MAX, 1);
+ extend_recovery_timer(obd, RECONNECT_DELAY_MAX, true);
/** Wait for recovery events again, after evicting bad clients */
goto repeat;
}
lu_context_fini(&req->rq_recov_session);
/* don't reset timer for final stage */
if (!exp_finished(req->rq_export)) {
+ int to = obd_timeout;
+
/**
* Add request timeout to the recovery time so next request from
* this client may come in recovery time
*/
- reset_recovery_timer(class_exp2obd(req->rq_export),
- AT_OFF ? obd_timeout :
- lustre_msg_get_timeout(req->rq_reqmsg), 1);
+ if (!AT_OFF) {
+ struct ptlrpc_service *svc = req->rq_rqbd->rqbd_service;
+ /* If the server sent early reply for this request,
+ * the client will recalculate the timeout according to
+ * current server estimate service time, so we will
+ * use the maxium timeout here for waiting the client
+ * sending the next req */
+ to = max((int)at_est2timeout(
+ at_get(&svc->srv_at_estimate)),
+ (int)lustre_msg_get_timeout(req->rq_reqmsg));
+ /* Add net_latency (see ptlrpc_replay_req) */
+ to += lustre_msg_get_service_time(req->rq_reqmsg);
+ }
+ extend_recovery_timer(class_exp2obd(req->rq_export), to, true);
}
reqcopy_put:
RETURN(rc);
struct target_recovery_data *trd = &obd->obd_recovery_data;
unsigned long delta;
unsigned long flags;
- struct lu_env env;
- struct ptlrpc_thread fake_svc_thread, *thread = &fake_svc_thread;
+ struct lu_env *env;
+ struct ptlrpc_thread *thread = NULL;
int rc = 0;
ENTRY;
RECALC_SIGPENDING;
SIGNAL_MASK_UNLOCK(current, flags);
- rc = lu_context_init(&env.le_ctx, LCT_MD_THREAD);
- if (rc)
+ OBD_ALLOC_PTR(thread);
+ if (thread == NULL)
+ RETURN(-ENOMEM);
+
+ OBD_ALLOC_PTR(env);
+ if (env == NULL) {
+ OBD_FREE_PTR(thread);
+ RETURN(-ENOMEM);
+ }
+
+ rc = lu_context_init(&env->le_ctx, LCT_MD_THREAD);
+ if (rc) {
+ OBD_FREE_PTR(thread);
+ OBD_FREE_PTR(env);
RETURN(rc);
+ }
- thread->t_env = &env;
+ thread->t_env = env;
thread->t_id = -1; /* force filter_iobuf_get/put to use local buffers */
- env.le_ctx.lc_thread = thread;
+ env->le_ctx.lc_thread = thread;
thread->t_data = NULL;
+ thread->t_watchdog = NULL;
- CERROR("%s: started recovery thread pid %d\n", obd->obd_name,
+ CDEBUG(D_HA, "%s: started recovery thread pid %d\n", obd->obd_name,
cfs_curproc_pid());
trd->trd_processing_task = cfs_curproc_pid();
target_finish_recovery(obd);
- lu_context_fini(&env.le_ctx);
+ lu_context_fini(&env->le_ctx);
trd->trd_processing_task = 0;
cfs_complete(&trd->trd_finishing);
+
+ OBD_FREE_PTR(thread);
+ OBD_FREE_PTR(env);
RETURN(rc);
}
" after %lds (%d clients connected)\n",
obd->obd_name, cfs_atomic_read(&obd->obd_lock_replay_clients),
cfs_time_current_sec()- obd->obd_recovery_start,
- obd->obd_connected_clients);
+ cfs_atomic_read(&obd->obd_connected_clients));
obd->obd_recovery_expired = 1;
cfs_waitq_signal(&obd->obd_next_transno_waitq);
obd->obd_recovery_start = 0;
obd->obd_recovery_end = 0;
- /* both values can be get from mount data already */
- if (obd->obd_recovery_timeout == 0)
- obd->obd_recovery_timeout = OBD_RECOVERY_TIME_SOFT;
- if (obd->obd_recovery_time_hard == 0)
- obd->obd_recovery_time_hard = OBD_RECOVERY_TIME_HARD;
cfs_timer_init(&obd->obd_recovery_timer, target_recovery_expired, obd);
target_start_recovery_thread(lut, handler);
}
/* CAVEAT EMPTOR: The incoming request message has been swabbed
* (i.e. buflens etc are in my own byte order), but type-dependent
- * buffers (eg mds_body, ost_body etc) have NOT been swabbed. */
+ * buffers (eg mdt_body, ost_body etc) have NOT been swabbed. */
if (!transno) {
CFS_INIT_LIST_HEAD(&req->rq_list);
}
if (unlikely(rc)) {
- DEBUG_REQ(D_ERROR, req, "processing error (%d)", rc);
+ DEBUG_REQ(D_NET, req, "processing error (%d)", rc);
req->rq_status = rc;
return (ptlrpc_send_error(req, 1));
} else {
{
int netrc;
struct ptlrpc_reply_state *rs;
- struct obd_device *obd;
struct obd_export *exp;
struct ptlrpc_service *svc;
ENTRY;
LASSERT (cfs_list_empty(&rs->rs_exp_list));
exp = class_export_get (req->rq_export);
- obd = exp->exp_obd;
/* disable reply scheduling while I'm setting up */
rs->rs_scheduled = 1;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff