* GPL HEADER END
*/
/*
- * Copyright 2008 Sun Microsystems, Inc. All rights reserved
+ * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*/
/*
int pcaa_initial_connect;
};
+/**
+ * Updates import \a imp current state to provided \a state value
+ * Helper function. Must be called under imp_lock.
+ */
static void __import_set_state(struct obd_import *imp,
enum lustre_imp_state state)
{
*uuid_len -= strlen(UUID_STR);
}
-/* Returns true if import was FULL, false if import was already not
+/**
+ * Returns true if import was FULL, false if import was already not
* connected.
* @imp - import to be disconnected
* @conn_cnt - connection count (epoch) of the request that timed out
return timeout;
}
-/*
+/**
* This function will invalidate the import, if necessary, then block
* for all the RPC completions, and finally notify the obd to
* invalidate its state (ie cancel locks, clear pending requests,
cfs_atomic_inc(&imp->imp_inval_count);
- /*
- * If this is an invalid MGC connection, then don't bother
- * waiting for imp_inflight to drop to 0.
- */
- if (imp->imp_invalid && imp->imp_recon_bk &&!imp->imp_obd->obd_no_recov)
- goto out;
-
if (!imp->imp_invalid || imp->imp_obd->obd_no_recov)
ptlrpc_deactivate_import(imp);
* "invalidate" state.
*/
LASSERT(cfs_atomic_read(&imp->imp_inflight) == 0);
-out:
obd_import_event(imp->imp_obd, imp, IMP_EVENT_INVALIDATE);
sptlrpc_import_flush_all_ctx(imp);
EXPORT_SYMBOL(ptlrpc_reconnect_import);
+/**
+ * Connection on import \a imp is changed to another one (if more than one is
+ * present). We typically chose connection that we have not tried to connect to
+ * the longest
+ */
static int import_select_connection(struct obd_import *imp)
{
struct obd_import_conn *imp_conn = NULL, *conn;
we do finally connect. (FIXME: really we should wait for all network
state associated with the last connection attempt to drain before
trying to reconnect on it.) */
- if (tried_all && (imp->imp_conn_list.next == &imp_conn->oic_item) &&
- !imp->imp_recon_bk /* not retrying */) {
+ if (tried_all && (imp->imp_conn_list.next == &imp_conn->oic_item)) {
if (at_get(&imp->imp_at.iat_net_latency) <
CONNECTION_SWITCH_MAX) {
at_measured(&imp->imp_at.iat_net_latency,
return 1;
}
+/**
+ * Attempt to (re)connect import \a imp. This includes all preparations,
+ * initializing CONNECT RPC request and passing it to ptlrpcd for
+ * actual sending.
+ * Returns 0 on success or error code.
+ */
int ptlrpc_connect_import(struct obd_import *imp, char *new_uuid)
{
struct obd_device *obd = imp->imp_obd;
if (rc)
GOTO(out, rc);
- /* last in connection list */
- if (imp->imp_conn_current->oic_item.next == &imp->imp_conn_list) {
- if (imp->imp_initial_recov_bk && initial_connect) {
- CDEBUG(D_HA, "Last connection attempt (%d) for %s\n",
- imp->imp_conn_cnt, obd2cli_tgt(imp->imp_obd));
- /* Don't retry if connect fails */
- rc = 0;
- obd_set_info_async(obd->obd_self_export,
- sizeof(KEY_INIT_RECOV),
- KEY_INIT_RECOV,
- sizeof(rc), &rc, NULL);
- }
- if (imp->imp_recon_bk) {
- CDEBUG(D_HA, "Last reconnection attempt (%d) for %s\n",
- imp->imp_conn_cnt, obd2cli_tgt(imp->imp_obd));
- cfs_spin_lock(&imp->imp_lock);
- imp->imp_last_recon = 1;
- cfs_spin_unlock(&imp->imp_lock);
- }
- }
-
rc = sptlrpc_import_sec_adapt(imp, NULL, 0);
if (rc)
GOTO(out, rc);
* the server is updated on-the-fly we will get the new features. */
imp->imp_connect_data.ocd_connect_flags = imp->imp_connect_flags_orig;
imp->imp_msghdr_flags &= ~MSGHDR_AT_SUPPORT;
+ imp->imp_msghdr_flags &= ~MSGHDR_CKSUM_INCOMPAT18;
rc = obd_reconnect(NULL, imp->imp_obd->obd_self_export, obd,
&obd->obd_uuid, &imp->imp_connect_data, NULL);
return (rc == -EBUSY) || (rc == -EAGAIN);
}
-
+/**
+ * interpret_reply callback for connect RPCs.
+ * Looks into returned status of connect operation and decides
+ * what to do with the import - i.e enter recovery, promote it to
+ * full state for normal operations of disconnect it due to an error.
+ */
static int ptlrpc_connect_interpret(const struct lu_env *env,
struct ptlrpc_request *request,
void *data, int rc)
"after reconnect. We should LBUG right here.\n");
}
- if (lustre_msg_get_last_committed(request->rq_repmsg) <
+ if (lustre_msg_get_last_committed(request->rq_repmsg) > 0 &&
+ lustre_msg_get_last_committed(request->rq_repmsg) <
aa->pcaa_peer_committed) {
CERROR("%s went back in time (transno "LPD64
" was previously committed, server now claims "LPD64
else
imp->imp_msghdr_flags &= ~MSGHDR_AT_SUPPORT;
+ if ((ocd->ocd_connect_flags & OBD_CONNECT_FULL20) &&
+ (imp->imp_msg_magic == LUSTRE_MSG_MAGIC_V2))
+ imp->imp_msghdr_flags |= MSGHDR_CKSUM_INCOMPAT18;
+ else
+ imp->imp_msghdr_flags &= ~MSGHDR_CKSUM_INCOMPAT18;
+
LASSERT((cli->cl_max_pages_per_rpc <= PTLRPC_MAX_BRW_PAGES) &&
(cli->cl_max_pages_per_rpc > 0));
}
out:
if (rc != 0) {
IMPORT_SET_STATE(imp, LUSTRE_IMP_DISCON);
- cfs_spin_lock(&imp->imp_lock);
- if (aa->pcaa_initial_connect && !imp->imp_initial_recov &&
- (request->rq_import_generation == imp->imp_generation))
- ptlrpc_deactivate_and_unlock_import(imp);
- else
- cfs_spin_unlock(&imp->imp_lock);
-
- if ((imp->imp_recon_bk && imp->imp_last_recon) ||
- (rc == -EACCES)) {
+ if (rc == -EACCES) {
/*
* Give up trying to reconnect
* EACCES means client has no permission for connection
(char *)imp->imp_connection->c_remote_uuid.uuid, rc);
}
- cfs_spin_lock(&imp->imp_lock);
- imp->imp_last_recon = 0;
- cfs_spin_unlock(&imp->imp_lock);
-
cfs_waitq_broadcast(&imp->imp_recovery_waitq);
RETURN(rc);
}
+/**
+ * interpret callback for "completed replay" RPCs.
+ * \see signal_completed_replay
+ */
static int completed_replay_interpret(const struct lu_env *env,
struct ptlrpc_request *req,
void * data, int rc)
RETURN(0);
}
+/**
+ * Let server know that we have no requests to replay anymore.
+ * Achieved by just sending a PING request
+ */
static int signal_completed_replay(struct obd_import *imp)
{
struct ptlrpc_request *req;
}
#ifdef __KERNEL__
+/**
+ * In kernel code all import invalidation happens in its own
+ * separate thread, so that whatever application happened to encounter
+ * a problem could still be killed or otherwise continue
+ */
static int ptlrpc_invalidate_import_thread(void *data)
{
struct obd_import *imp = data;
}
#endif
+/**
+ * This is the state machine for client-side recovery on import.
+ *
+ * Typicaly we have two possibly paths. If we came to server and it is not
+ * in recovery, we just enter IMP_EVICTED state, invalidate our import
+ * state and reconnect from scratch.
+ * If we came to server that is in recovery, we enter IMP_REPLAY import state.
+ * We go through our list of requests to replay and send them to server one by
+ * one.
+ * After sending all request from the list we change import state to
+ * IMP_REPLAY_LOCKS and re-request all the locks we believe we have from server
+ * and also all the locks we don't yet have and wait for server to grant us.
+ * After that we send a special "replay completed" request and change import
+ * state to IMP_REPLAY_WAIT.
+ * Upon receiving reply to that "replay completed" RPC we enter IMP_RECOVER
+ * state and resend all requests from sending list.
+ * After that we promote import to FULL state and send all delayed requests
+ * and import is fully operational after that.
+ *
+ */
int ptlrpc_import_recovery_state_machine(struct obd_import *imp)
{
int rc = 0;
RETURN(rc);
}
-static int back_to_sleep(void *unused)
-{
- return 0;
-}
-
int ptlrpc_disconnect_import(struct obd_import *imp, int noclose)
{
struct ptlrpc_request *req;
else
IMPORT_SET_STATE_NOLOCK(imp, LUSTRE_IMP_CLOSED);
memset(&imp->imp_remote_handle, 0, sizeof(imp->imp_remote_handle));
- /* Try all connections in the future - bz 12758 */
- imp->imp_last_recon = 0;
cfs_spin_unlock(&imp->imp_lock);
RETURN(rc);