*
* Copyright (c) 2011, 2017, Intel Corporation.
*
- * This file is part of Lustre, https://wiki.hpdd.intel.com/
+ * This file is part of Lustre, https://wiki.whamcloud.com/
*
* Portals is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
return net->net_tunables.lct_peer_tx_credits;
}
-/* forward ref's */
-static int lnet_router_checker(void *);
-
static int check_routers_before_use;
module_param(check_routers_before_use, int, 0444);
MODULE_PARM_DESC(check_routers_before_use, "Assume routers are down and ping them before use");
void
lnet_notify_locked(struct lnet_peer_ni *lp, int notifylnd, int alive,
- cfs_time_t when)
+ time64_t when)
{
- if (cfs_time_before(when, lp->lpni_timestamp)) { /* out of date information */
+ if (lp->lpni_timestamp > when) { /* out of date information */
CDEBUG(D_NET, "Out of date\n");
return;
}
*/
spin_lock(&lp->lpni_lock);
- lp->lpni_timestamp = when; /* update timestamp */
+ lp->lpni_timestamp = when; /* update timestamp */
lp->lpni_ping_deadline = 0; /* disable ping timeout */
if (lp->lpni_alive_count != 0 && /* got old news */
if (rnet != rnet2)
LIBCFS_FREE(rnet, sizeof(*rnet));
- /* indicate to startup the router checker if configured */
- wake_up(&the_lnet.ln_rc_waitq);
+ /* kick start the monitor thread to handle the added route */
+ wake_up(&the_lnet.ln_mt_waitq);
return rc;
}
* we ping alive routers to try to detect router death before
* apps get burned). */
- lnet_notify_locked(lp, 1, (event->status == 0), cfs_time_current());
+ lnet_notify_locked(lp, 1, !event->status, ktime_get_seconds());
/* The router checker will wake up very shortly and do the
* actual notification.
* XXX If 'lp' stops being a router before then, it will still
struct list_head *entry;
int all_known;
- LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING);
+ LASSERT(the_lnet.ln_mt_state == LNET_MT_STATE_RUNNING);
for (;;) {
int cpt = lnet_net_lock_current();
{
struct lnet_ni *ni = NULL;
time64_t now;
- int timeout;
+ time64_t timeout;
LASSERT(the_lnet.ln_routing);
LASSERT(ni->ni_status != NULL);
if (ni->ni_status->ns_status != LNET_NI_STATUS_DOWN) {
- CDEBUG(D_NET, "NI(%s:%d) status changed to down\n",
+ CDEBUG(D_NET, "NI(%s:%lld) status changed to down\n",
libcfs_nid2str(ni->ni_nid), timeout);
/* NB: so far, this is the only place to set
* NI status to "down" */
lnet_ping_router_locked(struct lnet_peer_ni *rtr)
{
struct lnet_rc_data *rcd = NULL;
- cfs_time_t now = cfs_time_current();
- int secs;
- struct lnet_ni *ni;
+ time64_t now = ktime_get_seconds();
+ time64_t secs;
+ struct lnet_ni *ni;
lnet_peer_ni_addref_locked(rtr);
if (rtr->lpni_ping_deadline != 0 && /* ping timed out? */
- cfs_time_after(now, rtr->lpni_ping_deadline))
+ now > rtr->lpni_ping_deadline)
lnet_notify_locked(rtr, 1, 0, now);
/* Run any outstanding notifications */
lnet_ni_notify_locked(ni, rtr);
if (!lnet_isrouter(rtr) ||
- the_lnet.ln_rc_state != LNET_RC_STATE_RUNNING) {
+ the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING) {
/* router table changed or router checker is shutting down */
lnet_peer_ni_decref_locked(rtr);
return;
}
rcd = rtr->lpni_rcd;
- if (!rcd || rcd->rcd_nnis > rcd->rcd_pingbuffer->pb_nnis)
+
+ /*
+ * The response to the router checker ping could've timed out and
+ * the mdh might've been invalidated, so we need to update it
+ * again.
+ */
+ if (!rcd || rcd->rcd_nnis > rcd->rcd_pingbuffer->pb_nnis ||
+ LNetMDHandleIsInvalid(rcd->rcd_mdh))
rcd = lnet_update_rc_data_locked(rtr);
if (rcd == NULL)
return;
secs = lnet_router_check_interval(rtr);
CDEBUG(D_NET,
- "rtr %s %d: deadline %lu ping_notsent %d alive %d "
- "alive_count %d lpni_ping_timestamp %lu\n",
+ "rtr %s %lld: deadline %lld ping_notsent %d alive %d "
+ "alive_count %d lpni_ping_timestamp %lld\n",
libcfs_nid2str(rtr->lpni_nid), secs,
rtr->lpni_ping_deadline, rtr->lpni_ping_notsent,
rtr->lpni_alive, rtr->lpni_alive_count, rtr->lpni_ping_timestamp);
if (secs != 0 && !rtr->lpni_ping_notsent &&
- cfs_time_after(now, cfs_time_add(rtr->lpni_ping_timestamp,
- cfs_time_seconds(secs)))) {
+ now > rtr->lpni_ping_timestamp + secs) {
int rc;
struct lnet_process_id id;
struct lnet_handle_md mdh;
mdh = rcd->rcd_mdh;
if (rtr->lpni_ping_deadline == 0) {
- rtr->lpni_ping_deadline =
- cfs_time_shift(router_ping_timeout);
+ rtr->lpni_ping_deadline = ktime_get_seconds() +
+ router_ping_timeout;
}
lnet_net_unlock(rtr->lpni_cpt);
rc = LNetGet(LNET_NID_ANY, mdh, id, LNET_RESERVED_PORTAL,
- LNET_PROTO_PING_MATCHBITS, 0);
+ LNET_PROTO_PING_MATCHBITS, 0, false);
lnet_net_lock(rtr->lpni_cpt);
if (rc != 0)
return;
}
-int
-lnet_router_checker_start(void)
+int lnet_router_pre_mt_start(void)
{
- int rc;
- int eqsz = 0;
- struct task_struct *task;
-
- LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_SHUTDOWN);
+ int rc;
if (check_routers_before_use &&
dead_router_check_interval <= 0) {
return -EINVAL;
}
- sema_init(&the_lnet.ln_rc_signal, 0);
-
rc = LNetEQAlloc(0, lnet_router_checker_event, &the_lnet.ln_rc_eqh);
if (rc != 0) {
- CERROR("Can't allocate EQ(%d): %d\n", eqsz, rc);
+ CERROR("Can't allocate EQ(0): %d\n", rc);
return -ENOMEM;
}
- the_lnet.ln_rc_state = LNET_RC_STATE_RUNNING;
- task = kthread_run(lnet_router_checker, NULL, "router_checker");
- if (IS_ERR(task)) {
- rc = PTR_ERR(task);
- CERROR("Can't start router checker thread: %d\n", rc);
- /* block until event callback signals exit */
- down(&the_lnet.ln_rc_signal);
- rc = LNetEQFree(the_lnet.ln_rc_eqh);
- LASSERT(rc == 0);
- the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
- return -ENOMEM;
- }
+ return 0;
+}
+void lnet_router_post_mt_start(void)
+{
if (check_routers_before_use) {
/* Note that a helpful side-effect of pinging all known routers
* at startup is that it makes them drop stale connections they
* may have to a previous instance of me. */
lnet_wait_known_routerstate();
}
-
- return 0;
}
void
-lnet_router_checker_stop (void)
+lnet_router_cleanup(void)
{
int rc;
- if (the_lnet.ln_rc_state == LNET_RC_STATE_SHUTDOWN)
- return;
-
- LASSERT (the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING);
- the_lnet.ln_rc_state = LNET_RC_STATE_STOPPING;
- /* wakeup the RC thread if it's sleeping */
- wake_up(&the_lnet.ln_rc_waitq);
-
- /* block until event callback signals exit */
- down(&the_lnet.ln_rc_signal);
- LASSERT(the_lnet.ln_rc_state == LNET_RC_STATE_SHUTDOWN);
-
rc = LNetEQFree(the_lnet.ln_rc_eqh);
LASSERT(rc == 0);
return;
}
-static void
+void
lnet_prune_rc_data(int wait_unlink)
{
struct lnet_rc_data *rcd;
struct list_head head;
int i = 2;
- if (likely(the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING &&
+ if (likely(the_lnet.ln_mt_state == LNET_MT_STATE_RUNNING &&
list_empty(&the_lnet.ln_rcd_deathrow) &&
list_empty(&the_lnet.ln_rcd_zombie)))
return;
lnet_net_lock(LNET_LOCK_EX);
- if (the_lnet.ln_rc_state != LNET_RC_STATE_RUNNING) {
+ if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING) {
/* router checker is stopping, prune all */
list_for_each_entry(lp, &the_lnet.ln_routers,
lpni_rtr_list) {
}
/*
- * This function is called to check if the RC should block indefinitely.
- * It's called from lnet_router_checker() as well as being passed to
- * wait_event_interruptible() to avoid the lost wake_up problem.
- *
- * When it's called from wait_event_interruptible() it is necessary to
- * also not sleep if the rc state is not running to avoid a deadlock
- * when the system is shutting down
+ * This function is called from the monitor thread to check if there are
+ * any active routers that need to be checked.
*/
-static inline bool
+inline bool
lnet_router_checker_active(void)
{
- if (the_lnet.ln_rc_state != LNET_RC_STATE_RUNNING)
+ if (the_lnet.ln_mt_state != LNET_MT_STATE_RUNNING)
return true;
/* Router Checker thread needs to run when routing is enabled in
if (the_lnet.ln_routing)
return true;
+ /* if there are routers that need to be cleaned up then do so */
+ if (!list_empty(&the_lnet.ln_rcd_deathrow) ||
+ !list_empty(&the_lnet.ln_rcd_zombie))
+ return true;
+
return !list_empty(&the_lnet.ln_routers) &&
(live_router_check_interval > 0 ||
dead_router_check_interval > 0);
}
-static int
-lnet_router_checker(void *arg)
+void
+lnet_check_routers(void)
{
struct lnet_peer_ni *rtr;
struct list_head *entry;
+ __u64 version;
+ int cpt;
+ int cpt2;
- cfs_block_allsigs();
-
- while (the_lnet.ln_rc_state == LNET_RC_STATE_RUNNING) {
- __u64 version;
- int cpt;
- int cpt2;
-
- cpt = lnet_net_lock_current();
+ cpt = lnet_net_lock_current();
rescan:
- version = the_lnet.ln_routers_version;
-
- list_for_each(entry, &the_lnet.ln_routers) {
- rtr = list_entry(entry, struct lnet_peer_ni,
- lpni_rtr_list);
-
- cpt2 = rtr->lpni_cpt;
- if (cpt != cpt2) {
- lnet_net_unlock(cpt);
- cpt = cpt2;
- lnet_net_lock(cpt);
- /* the routers list has changed */
- if (version != the_lnet.ln_routers_version)
- goto rescan;
- }
+ version = the_lnet.ln_routers_version;
- lnet_ping_router_locked(rtr);
+ list_for_each(entry, &the_lnet.ln_routers) {
+ rtr = list_entry(entry, struct lnet_peer_ni,
+ lpni_rtr_list);
- /* NB dropped lock */
- if (version != the_lnet.ln_routers_version) {
- /* the routers list has changed */
+ cpt2 = rtr->lpni_cpt;
+ if (cpt != cpt2) {
+ lnet_net_unlock(cpt);
+ cpt = cpt2;
+ lnet_net_lock(cpt);
+ /* the routers list has changed */
+ if (version != the_lnet.ln_routers_version)
goto rescan;
- }
}
- if (the_lnet.ln_routing)
- lnet_update_ni_status_locked();
-
- lnet_net_unlock(cpt);
-
- lnet_prune_rc_data(0); /* don't wait for UNLINK */
+ lnet_ping_router_locked(rtr);
- /* Call schedule_timeout() here always adds 1 to load average
- * because kernel counts # active tasks as nr_running
- * + nr_uninterruptible. */
- /* if there are any routes then wakeup every second. If
- * there are no routes then sleep indefinitely until woken
- * up by a user adding a route */
- if (!lnet_router_checker_active())
- wait_event_interruptible(the_lnet.ln_rc_waitq,
- lnet_router_checker_active());
- else
- wait_event_interruptible_timeout(the_lnet.ln_rc_waitq,
- false,
- cfs_time_seconds(1));
+ /* NB dropped lock */
+ if (version != the_lnet.ln_routers_version) {
+ /* the routers list has changed */
+ goto rescan;
+ }
}
- lnet_prune_rc_data(1); /* wait for UNLINK */
+ if (the_lnet.ln_routing)
+ lnet_update_ni_status_locked();
+
+ lnet_net_unlock(cpt);
- the_lnet.ln_rc_state = LNET_RC_STATE_SHUTDOWN;
- up(&the_lnet.ln_rc_signal);
- /* The unlink event callback will signal final completion */
- return 0;
+ lnet_prune_rc_data(0); /* don't wait for UNLINK */
}
void
}
int
-lnet_notify(struct lnet_ni *ni, lnet_nid_t nid, int alive, cfs_time_t when)
+lnet_notify(struct lnet_ni *ni, lnet_nid_t nid, int alive, time64_t when)
{
struct lnet_peer_ni *lp = NULL;
- cfs_time_t now = cfs_time_current();
+ time64_t now = ktime_get_seconds();
int cpt = lnet_cpt_of_nid(nid, ni);
LASSERT (!in_interrupt ());
}
/* can't do predictions... */
- if (cfs_time_after(when, now)) {
+ if (when > now) {
CWARN("Ignoring prediction from %s of %s %s "
- "%ld seconds in the future\n",
+ "%lld seconds in the future\n",
(ni == NULL) ? "userspace" : libcfs_nid2str(ni->ni_nid),
- libcfs_nid2str(nid), alive ? "up" : "down",
- cfs_duration_sec(cfs_time_sub(when, now)));
+ libcfs_nid2str(nid), alive ? "up" : "down", when - now);
return -EINVAL;
}