* 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/
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)
* 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)
{
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;
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() */
struct obd_connect_data *ocd;
struct lustre_handle conn = { 0 };
int rc;
- bool is_mdc = false;
ENTRY;
*exp = NULL;
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);
}
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;
}
ptlrpc_pinger_add_import(imp);
}
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;
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);
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"
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)
return;
}
- cfs_timer_arm(&obd->obd_recovery_timer,
- cfs_time_shift(obd->obd_recovery_timeout));
+ mod_timer(&obd->obd_recovery_timer,
+ cfs_time_shift(obd->obd_recovery_timeout));
obd->obd_recovery_start = cfs_time_current_sec();
spin_unlock(&obd->obd_dev_lock);
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: %d, 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);
* 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. */
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);
}
" extend recovery %d\n", obd->obd_name,
obd->obd_recovery_timeout);
return 0;
- } else {
- dtrq_list_dump(lut->lut_tdtd, D_HA);
}
}
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);