list_for_each_entry(item, &imp->imp_conn_list, oic_item) {
if (obd_uuid_equals(uuid, &item->oic_uuid)) {
if (priority) {
- list_del(&item->oic_item);
- list_add(&item->oic_item,
- &imp->imp_conn_list);
+ list_move(&item->oic_item,
+ &imp->imp_conn_list);
item->oic_last_attempt = 0;
}
CDEBUG(D_HA, "imp %p@%s: found existing conn %s%s\n",
init_waitqueue_head(&cli->cl_destroy_waitq);
atomic_set(&cli->cl_destroy_in_flight, 0);
+
cli->cl_supp_cksum_types = OBD_CKSUM_CRC32;
+ cli->cl_preferred_cksum_type = 0;
#ifdef ENABLE_CHECKSUM
/* Turn on checksumming by default. */
cli->cl_checksum = 1;
if (!strcmp(name, LUSTRE_MDC_NAME)) {
cli->cl_max_rpcs_in_flight = OBD_MAX_RIF_DEFAULT;
- } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 128 /* MB */) {
+ } else if (cfs_totalram_pages() >> (20 - PAGE_SHIFT) <= 128 /* MB */) {
cli->cl_max_rpcs_in_flight = 2;
- } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 256 /* MB */) {
+ } else if (cfs_totalram_pages() >> (20 - PAGE_SHIFT) <= 256 /* MB */) {
cli->cl_max_rpcs_in_flight = 3;
- } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 512 /* MB */) {
+ } else if (cfs_totalram_pages() >> (20 - PAGE_SHIFT) <= 512 /* MB */) {
cli->cl_max_rpcs_in_flight = 4;
} else {
if (osc_on_mdt(obddev->obd_name))
target->obd_name,
obd_uuid2str(&exp->exp_client_uuid),
obd_export_nid2str(exp),
- target->obd_max_recoverable_clients,
+ atomic_read(&target->obd_max_recoverable_clients),
timeout / 60, timeout % 60);
} else {
struct target_distribute_txn_data *tdtd;
size = req_capsule_get_size(&req->rq_pill, &RMF_CONNECT_DATA,
RCL_CLIENT);
+ if (size < 0 || size > 8 * sizeof(struct obd_connect_data))
+ GOTO(out, rc = -EPROTO);
data = req_capsule_client_get(&req->rq_pill, &RMF_CONNECT_DATA);
if (!data)
GOTO(out, rc = -EPROTO);
CDEBUG(D_HA, "%s: connection from %s@%s %st%llu exp %p cur %lld last %lld\n",
target->obd_name, cluuid.uuid, libcfs_nid2str(req->rq_peer.nid),
target->obd_recovering ? "recovering/" : "", data->ocd_transno,
- export, ktime_get_real_seconds(),
+ export, ktime_get_seconds(),
export ? export->exp_last_request_time : 0);
/*
connected = atomic_read(&target->obd_connected_clients);
in_progress = atomic_read(&target->obd_lock_replay_clients);
- known = target->obd_max_recoverable_clients;
+ known =
+ atomic_read(&target->obd_max_recoverable_clients);
stale = target->obd_stale_clients;
remaining = hrtimer_expires_remaining(timer);
left = ktime_divns(remaining, NSEC_PER_SEC);
* condition.
*/
if (new_mds_mds_conn)
- target->obd_max_recoverable_clients++;
+ atomic_inc(&target->obd_max_recoverable_clients);
+
if (atomic_inc_return(&target->obd_connected_clients) ==
- target->obd_max_recoverable_clients)
+ atomic_read(&target->obd_max_recoverable_clients))
wake_up(&target->obd_next_transno_waitq);
}
/* Only log a recovery message when recovery has occurred. */
if (obd->obd_recovery_start) {
- time64_t now = ktime_get_real_seconds();
+ time64_t now = ktime_get_seconds();
time64_t elapsed_time;
elapsed_time = max_t(time64_t, now - obd->obd_recovery_start,
LCONSOLE_INFO("%s: Recovery over after %lld:%.02lld, of %d clients %d recovered and %d %s evicted.\n",
obd->obd_name, (s64)elapsed_time / 60,
(s64)elapsed_time % 60,
- obd->obd_max_recoverable_clients,
+ atomic_read(&obd->obd_max_recoverable_clients),
atomic_read(&obd->obd_connected_clients),
obd->obd_stale_clients,
obd->obd_stale_clients == 1 ? "was" : "were");
}
spin_unlock(&obd->obd_recovery_task_lock);
- obd->obd_recovery_end = ktime_get_real_seconds();
+ obd->obd_recovery_end = ktime_get_seconds();
/* When recovery finished, cleanup orphans on MDS and OST. */
if (obd->obd_type && OBP(obd, postrecov)) {
return;
}
- delay = ktime_set(obd->obd_recovery_timeout, 0);
- hrtimer_start(&obd->obd_recovery_timer, delay, HRTIMER_MODE_REL);
- obd->obd_recovery_start = ktime_get_real_seconds();
+ obd->obd_recovery_start = ktime_get_seconds();
+ delay = ktime_set(obd->obd_recovery_start +
+ obd->obd_recovery_timeout, 0);
+ hrtimer_start(&obd->obd_recovery_timer, delay, HRTIMER_MODE_ABS);
spin_unlock(&obd->obd_dev_lock);
- LCONSOLE_WARN("%s: Will be in recovery for at least %llu:%02llu, or until %d client%s reconnect%s\n",
+ LCONSOLE_WARN("%s: Will be in recovery for at least %lu:%02lu, 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" : "");
+ atomic_read(&obd->obd_max_recoverable_clients),
+ (atomic_read(&obd->obd_max_recoverable_clients) == 1) ?
+ "" : "s",
+ (atomic_read(&obd->obd_max_recoverable_clients) == 1) ?
+ "s" : "");
}
/**
obd->obd_name, timeout, extend);
if (obd->obd_recovery_timeout < timeout) {
- ktime_t now = ktime_get_real();
- ktime_t end;
+ ktime_t end, now;
obd->obd_recovery_timeout = timeout;
end = ktime_set(obd->obd_recovery_start + timeout, 0);
+ now = ktime_set(ktime_get_seconds(), 0);
left_ns = ktime_sub(end, now);
- hrtimer_forward_now(&obd->obd_recovery_timer, left_ns);
- left = ktime_divns(left_ns, NSEC_PER_MSEC);
+ hrtimer_start(&obd->obd_recovery_timer, end, HRTIMER_MODE_ABS);
+ left = ktime_divns(left_ns, NSEC_PER_SEC);
}
spin_unlock(&obd->obd_dev_lock);
CDEBUG(D_HA,
"max: %d, connected: %d, completed: %d, queue_len: %d, req_transno: %llu, next_transno: %llu\n",
- obd->obd_max_recoverable_clients, connected, completed,
+ atomic_read(&obd->obd_max_recoverable_clients),
+ connected, completed,
queue_len, req_transno, next_transno);
if (obd->obd_abort_recovery) {
last = now;
}
}
- if (obd->obd_recovery_start != 0 && ktime_get_real_seconds() >=
+ if (obd->obd_recovery_start != 0 && ktime_get_seconds() >=
(obd->obd_recovery_start + obd->obd_recovery_time_hard)) {
__u64 next_update_transno = 0;
while (wait_event_timeout(obd->obd_next_transno_waitq,
check_routine(lut),
- msecs_to_jiffies(60 * MSEC_PER_SEC)) == 0)
+ cfs_time_seconds(60)) == 0)
; /* wait indefinitely for event, but don't trigger watchdog */
if (obd->obd_abort_recovery) {
return 1;
} else if (obd->obd_recovery_expired) {
obd->obd_recovery_expired = 0;
+
/** If some clients died being recovered, evict them */
LCONSOLE_WARN("%s: recovery is timed out, evict stale exports\n",
obd->obd_name);
CDEBUG(D_HA,
"connected %d stale %d max_recoverable_clients %d abort %d expired %d\n",
- clnts, obd->obd_stale_clients, obd->obd_max_recoverable_clients,
+ clnts, obd->obd_stale_clients,
+ atomic_read(&obd->obd_max_recoverable_clients),
obd->obd_abort_recovery, obd->obd_recovery_expired);
if (!obd->obd_abort_recovery && !obd->obd_recovery_expired) {
- LASSERT(clnts <= obd->obd_max_recoverable_clients);
+ LASSERT(clnts <=
+ atomic_read(&obd->obd_max_recoverable_clients));
if (clnts + obd->obd_stale_clients <
- obd->obd_max_recoverable_clients)
+ atomic_read(&obd->obd_max_recoverable_clients))
return 0;
}
extend_recovery_timer(obd, obd->obd_recovery_timeout,
true);
CDEBUG(D_HA,
- "%s update recovery is not ready, extend recovery %llu\n",
+ "%s update recovery is not ready, extend recovery %lu\n",
obd->obd_name, obd->obd_recovery_timeout);
return 0;
}
struct ptlrpc_request *req)
{
DEBUG_REQ(D_HA, req,
- "remove t%lld from %s because of duplicate update records are found.\n",
+ "remove t%lld from %s because duplicate update records found",
lustre_msg_get_transno(req->rq_reqmsg),
libcfs_nid2str(req->rq_peer.nid));
lustre_msg_set_transno(req->rq_repmsg, req->rq_transno);
target_send_reply(req, req->rq_status, 0);
} else {
- DEBUG_REQ(D_ERROR, req, "wrong opc from %s\n",
+ DEBUG_REQ(D_ERROR, req, "wrong opc from %s",
libcfs_nid2str(req->rq_peer.nid));
}
target_exp_dequeue_req_replay(req);
atomic_read(&obd->obd_lock_replay_clients));
while ((req = target_next_replay_lock(lut))) {
LASSERT(trd->trd_processing_task == current_pid());
- DEBUG_REQ(D_HA, req, "processing lock from %s: ",
+ DEBUG_REQ(D_HA, req, "processing lock from %s:",
libcfs_nid2str(req->rq_peer.nid));
handle_recovery_req(thread, req,
trd->trd_recovery_handler);
spin_unlock(&obd->obd_recovery_task_lock);
while ((req = target_next_final_ping(obd))) {
LASSERT(trd->trd_processing_task == current_pid());
- DEBUG_REQ(D_HA, req, "processing final ping from %s: ",
+ DEBUG_REQ(D_HA, req, "processing final ping from %s:",
libcfs_nid2str(req->rq_peer.nid));
handle_recovery_req(thread, req,
trd->trd_recovery_handler);
if (lut->lut_bottom->dd_rdonly)
return;
- if (obd->obd_max_recoverable_clients == 0) {
+ if (atomic_read(&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_max_recoverable_clients, obd->obd_last_committed);
+ atomic_read(&obd->obd_max_recoverable_clients),
+ obd->obd_last_committed);
LASSERT(obd->obd_stopping == 0);
obd->obd_next_recovery_transno = obd->obd_last_committed + 1;
obd->obd_recovery_start = 0;
obd->obd_recovery_end = 0;
- hrtimer_init(&obd->obd_recovery_timer, CLOCK_REALTIME,
- HRTIMER_MODE_REL);
+ hrtimer_init(&obd->obd_recovery_timer, CLOCK_MONOTONIC,
+ HRTIMER_MODE_ABS);
obd->obd_recovery_timer.function = &target_recovery_expired;
target_start_recovery_thread(lut, handler);
}
if (duplicate != NULL) {
DEBUG_REQ(D_HA, duplicate,
- "put prev final req\n");
+ "put prev final req");
target_request_copy_put(duplicate);
}
RETURN(0);
return "UNKNOWN";
}
-int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc,
- struct l_wait_info *lwi)
+int target_bulk_io(struct obd_export *exp, struct ptlrpc_bulk_desc *desc)
{
struct ptlrpc_request *req = desc->bd_req;
- time64_t start = ktime_get_real_seconds();
+ time64_t start = ktime_get_seconds();
time64_t deadline;
+ struct l_wait_info lwi;
int rc = 0;
ENTRY;
/* If there is eviction in progress, wait for it to finish. */
if (unlikely(atomic_read(&exp->exp_obd->obd_evict_inprogress))) {
- *lwi = LWI_INTR(NULL, NULL);
+ lwi = LWI_INTR(NULL, NULL);
rc = l_wait_event(exp->exp_obd->obd_evict_inprogress_waitq,
!atomic_read(&exp->exp_obd->obd_evict_inprogress),
- lwi);
+ &lwi);
}
/* Check if client was evicted or reconnected already. */
}
if (rc < 0) {
- DEBUG_REQ(D_ERROR, req, "bulk %s failed: rc %d",
+ DEBUG_REQ(D_ERROR, req, "bulk %s failed: rc = %d",
bulk2type(req), rc);
RETURN(rc);
}
deadline = req->rq_deadline;
do {
- time64_t timeoutl = deadline - ktime_get_real_seconds();
+ time64_t timeoutl = deadline - ktime_get_seconds();
long timeout_jiffies = timeoutl <= 0 ?
1 : cfs_time_seconds(timeoutl);
time64_t rq_deadline;
- *lwi = LWI_TIMEOUT_INTERVAL(timeout_jiffies,
- cfs_time_seconds(1),
- target_bulk_timeout, desc);
+ lwi = LWI_TIMEOUT_INTERVAL(timeout_jiffies,
+ cfs_time_seconds(1),
+ target_bulk_timeout, desc);
rc = l_wait_event(desc->bd_waitq,
!ptlrpc_server_bulk_active(desc) ||
exp->exp_failed ||
exp->exp_conn_cnt >
lustre_msg_get_conn_cnt(req->rq_reqmsg),
- lwi);
+ &lwi);
LASSERT(rc == 0 || rc == -ETIMEDOUT);
/* Wait again if we changed rq_deadline. */
rq_deadline = READ_ONCE(req->rq_deadline);
if (deadline > rq_deadline)
deadline = rq_deadline;
} while (rc == -ETIMEDOUT &&
- deadline > ktime_get_real_seconds());
+ deadline > ktime_get_seconds());
if (rc == -ETIMEDOUT) {
DEBUG_REQ(D_ERROR, req, "timeout on bulk %s after %lld%+llds",