* 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/
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;
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,
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;
+ data->ocd_connect_flags2 = ocd->ocd_connect_flags2;
}
ptlrpc_pinger_add_import(imp);
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);
}
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;
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"
/* 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) ||
}
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)) {
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));
- 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": "");
}
/**
* 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;
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",
+ 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 */
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
* 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;
}
}
{
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;
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,
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);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff