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,
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;
+ 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);
/* 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)) {
mod_timer(&obd->obd_recovery_timer,
cfs_time_shift(obd->obd_recovery_timeout));
- obd->obd_recovery_start = cfs_time_current_sec();
+ 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);
}
}
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,