IB/ipath: Head of Line blocking vs forward progress of user apps (58411d1c) · Commits · 戴 / test

drivers/infiniband/hw/ipath/ipath_debug.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -66,6 +66,7 @@
		#define __IPATH_IPATHERR 0x40000 /* Ethernet (IPATH) errors */
		#define __IPATH_IPATHPD 0x80000 /* Ethernet (IPATH) packet dump */
		#define __IPATH_IPATHTABLE 0x100000 /* Ethernet (IPATH) table dump */
		#define __IPATH_LINKVERBDBG 0x200000 /* very verbose linkchange debug */

		#else /* _IPATH_DEBUGGING */

drivers/infiniband/hw/ipath/ipath_diag.c

+14 −4

Original line number	Diff line number	Diff line
		@@ -330,6 +330,7 @@ static ssize_t ipath_diagpkt_write(struct file *fp,
		struct ipath_devdata *dd;
		ssize_t ret = 0;
		u64 val;
		u32 l_state, lt_state; /* LinkState, LinkTrainingState */

		if (count != sizeof(dp)) {
		ret = -EINVAL;
		@@ -396,10 +397,17 @@ static ssize_t ipath_diagpkt_write(struct file *fp,
		ret = -ENODEV;
		goto bail;
		}
		/* Check link state, but not if we have custom PBC */
		val = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
		if (!dp.pbc_wd && val != IPATH_IBSTATE_INIT &&
		val != IPATH_IBSTATE_ARM && val != IPATH_IBSTATE_ACTIVE) {
		/*
		* Want to skip check for l_state if using custom PBC,
		* because we might be trying to force an SM packet out.
		* first-cut, skip _all_ state checking in that case.
		*/
		val = ipath_ib_state(dd, dd->ipath_lastibcstat);
		lt_state = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
		l_state = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
		if (!dp.pbc_wd && (lt_state != INFINIPATH_IBCS_LT_STATE_LINKUP \|\|
		(val != dd->ib_init && val != dd->ib_arm &&
		val != dd->ib_active))) {
		ipath_cdbg(VERBOSE, "unit %u not ready (state %llx)\n",
		dd->ipath_unit, (unsigned long long) val);
		ret = -EINVAL;
		@@ -438,6 +446,8 @@ static ssize_t ipath_diagpkt_write(struct file *fp,
		ret = -EBUSY;
		goto bail;
		}
		/* disarm it just to be extra sure */
		ipath_disarm_piobufs(dd, pbufn, 1);

		plen >>= 2; /* in dwords */

drivers/infiniband/hw/ipath/ipath_driver.c

+121 −8

Original line number	Diff line number	Diff line
		@@ -77,6 +77,11 @@ unsigned ipath_mtu4096 = 1; /* max 4KB IB mtu by default, if supported */
		module_param_named(mtu4096, ipath_mtu4096, uint, S_IRUGO);
		MODULE_PARM_DESC(mtu4096, "enable MTU of 4096 bytes, if supported");

		static unsigned ipath_hol_timeout_ms = 13000;
		module_param_named(hol_timeout_ms, ipath_hol_timeout_ms, uint, S_IRUGO);
		MODULE_PARM_DESC(hol_timeout_ms,
		"duration of user app suspension after link failure");

		MODULE_LICENSE("GPL");
		MODULE_AUTHOR("QLogic <support@pathscale.com>");
		MODULE_DESCRIPTION("QLogic InfiniPath driver");
		@@ -1670,11 +1675,8 @@ static void ipath_set_ib_lstate(struct ipath_devdata *dd, int which)
		ipath_cdbg(VERBOSE, "Trying to move unit %u to %s, current ltstate "
		"is %s\n", dd->ipath_unit,
		what[linkcmd],
		ipath_ibcstatus_str[
		(ipath_read_kreg64
		(dd, dd->ipath_kregs->kr_ibcstatus) >>
		INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKTRAININGSTATE_MASK]);
		ipath_ibcstatus_str[ipath_ib_linktrstate(dd,
		ipath_read_kreg64(dd, dd->ipath_kregs->kr_ibcstatus))]);
		/* flush all queued sends when going to DOWN to be sure that
		* they don't block MAD packets */
		if (linkcmd == INFINIPATH_IBCC_LINKCMD_DOWN)
		@@ -1925,9 +1927,8 @@ static void ipath_run_led_override(unsigned long opaque)
		*/
		val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_ibcstatus);
		ltstate = (val >> INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKTRAININGSTATE_MASK;
		lstate = (val >> INFINIPATH_IBCS_LINKSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKSTATE_MASK;
		dd->ibcs_lts_mask;
		lstate = (val >> dd->ibcs_ls_shift) & INFINIPATH_IBCS_LINKSTATE_MASK;

		dd->ipath_f_setextled(dd, lstate, ltstate);
		mod_timer(&dd->ipath_led_override_timer, jiffies + timeoff);
		@@ -1988,6 +1989,8 @@ void ipath_shutdown_device(struct ipath_devdata *dd)

		ipath_dbg("Shutting down the device\n");

		ipath_hol_up(dd); /* make sure user processes aren't suspended */

		dd->ipath_flags \|= IPATH_LINKUNK;
		dd->ipath_flags &= ~(IPATH_INITTED \| IPATH_LINKDOWN \|
		IPATH_LINKINIT \| IPATH_LINKARMED \|
		@@ -2037,6 +2040,8 @@ void ipath_shutdown_device(struct ipath_devdata *dd)
		*/
		dd->ipath_f_quiet_serdes(dd);

		/* stop all the timers that might still be running */
		del_timer_sync(&dd->ipath_hol_timer);
		if (dd->ipath_stats_timer_active) {
		del_timer_sync(&dd->ipath_stats_timer);
		dd->ipath_stats_timer_active = 0;
		@@ -2252,6 +2257,114 @@ bail:
		return ret;
		}

		/*
		* send a signal to all the processes that have the driver open
		* through the normal interfaces (i.e., everything other than diags
		* interface). Returns number of signalled processes.
		*/
		static int ipath_signal_procs(struct ipath_devdata *dd, int sig)
		{
		int i, sub, any = 0;
		pid_t pid;

		if (!dd->ipath_pd)
		return 0;
		for (i = 1; i < dd->ipath_cfgports; i++) {
		if (!dd->ipath_pd[i] \|\| !dd->ipath_pd[i]->port_cnt \|\|
		!dd->ipath_pd[i]->port_pid)
		continue;
		pid = dd->ipath_pd[i]->port_pid;
		dev_info(&dd->pcidev->dev, "context %d in use "
		"(PID %u), sending signal %d\n",
		i, pid, sig);
		kill_proc(pid, sig, 1);
		any++;
		for (sub = 0; sub < INFINIPATH_MAX_SUBPORT; sub++) {
		pid = dd->ipath_pd[i]->port_subpid[sub];
		if (!pid)
		continue;
		dev_info(&dd->pcidev->dev, "sub-context "
		"%d:%d in use (PID %u), sending "
		"signal %d\n", i, sub, pid, sig);
		kill_proc(pid, sig, 1);
		any++;
		}
		}
		return any;
		}

		static void ipath_hol_signal_down(struct ipath_devdata *dd)
		{
		if (ipath_signal_procs(dd, SIGSTOP))
		ipath_dbg("Stopped some processes\n");
		ipath_cancel_sends(dd, 1);
		}


		static void ipath_hol_signal_up(struct ipath_devdata *dd)
		{
		if (ipath_signal_procs(dd, SIGCONT))
		ipath_dbg("Continued some processes\n");
		}

		/*
		* link is down, stop any users processes, and flush pending sends
		* to prevent HoL blocking, then start the HoL timer that
		* periodically continues, then stop procs, so they can detect
		* link down if they want, and do something about it.
		* Timer may already be running, so use __mod_timer, not add_timer.
		*/
		void ipath_hol_down(struct ipath_devdata *dd)
		{
		dd->ipath_hol_state = IPATH_HOL_DOWN;
		ipath_hol_signal_down(dd);
		dd->ipath_hol_next = IPATH_HOL_DOWNCONT;
		dd->ipath_hol_timer.expires = jiffies +
		msecs_to_jiffies(ipath_hol_timeout_ms);
		__mod_timer(&dd->ipath_hol_timer, dd->ipath_hol_timer.expires);
		}

		/*
		* link is up, continue any user processes, and ensure timer
		* is a nop, if running. Let timer keep running, if set; it
		* will nop when it sees the link is up
		*/
		void ipath_hol_up(struct ipath_devdata *dd)
		{
		ipath_hol_signal_up(dd);
		dd->ipath_hol_state = IPATH_HOL_UP;
		}

		/*
		* toggle the running/not running state of user proceses
		* to prevent HoL blocking on chip resources, but still allow
		* user processes to do link down special case handling.
		* Should only be called via the timer
		*/
		void ipath_hol_event(unsigned long opaque)
		{
		struct ipath_devdata dd = (struct ipath_devdata )opaque;

		if (dd->ipath_hol_next == IPATH_HOL_DOWNSTOP
		&& dd->ipath_hol_state != IPATH_HOL_UP) {
		dd->ipath_hol_next = IPATH_HOL_DOWNCONT;
		ipath_dbg("Stopping processes\n");
		ipath_hol_signal_down(dd);
		} else { /* may do "extra" if also in ipath_hol_up() */
		dd->ipath_hol_next = IPATH_HOL_DOWNSTOP;
		ipath_dbg("Continuing processes\n");
		ipath_hol_signal_up(dd);
		}
		if (dd->ipath_hol_state == IPATH_HOL_UP)
		ipath_dbg("link's up, don't resched timer\n");
		else {
		dd->ipath_hol_timer.expires = jiffies +
		msecs_to_jiffies(ipath_hol_timeout_ms);
		__mod_timer(&dd->ipath_hol_timer,
		dd->ipath_hol_timer.expires);
		}
		}

		int ipath_set_rx_pol_inv(struct ipath_devdata *dd, u8 new_pol_inv)
		{
		u64 val;

drivers/infiniband/hw/ipath/ipath_init_chip.c

+6 −0

Original line number	Diff line number	Diff line
		@@ -908,6 +908,12 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
		dd->ipath_stats_timer_active = 1;
		}

		/* Set up HoL state */
		init_timer(&dd->ipath_hol_timer);
		dd->ipath_hol_timer.function = ipath_hol_event;
		dd->ipath_hol_timer.data = (unsigned long)dd;
		dd->ipath_hol_state = IPATH_HOL_UP;

		done:
		if (!ret) {
		*dd->ipath_statusp \|= IPATH_STATUS_CHIP_PRESENT;

drivers/infiniband/hw/ipath/ipath_intr.c

+136 −151

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@
		*/

		#include <linux/pci.h>
		#include <linux/delay.h>

		#include "ipath_kernel.h"
		#include "ipath_verbs.h"
		@@ -256,24 +257,20 @@ void ipath_format_hwerrors(u64 hwerrs,
		}

		/* return the strings for the most common link states */
		static char *ib_linkstate(u32 linkstate)
		static char ib_linkstate(struct ipath_devdata dd, u64 ibcs)
		{
		char *ret;
		u32 state;

		switch (linkstate) {
		case IPATH_IBSTATE_INIT:
		state = ipath_ib_state(dd, ibcs);
		if (state == dd->ib_init)
		ret = "Init";
		break;
		case IPATH_IBSTATE_ARM:
		else if (state == dd->ib_arm)
		ret = "Arm";
		break;
		case IPATH_IBSTATE_ACTIVE:
		else if (state == dd->ib_active)
		ret = "Active";
		break;
		default:
		else
		ret = "Down";
		}

		return ret;
		}

		@@ -288,170 +285,161 @@ void signal_ib_event(struct ipath_devdata *dd, enum ib_event_type ev)
		}

		static void handle_e_ibstatuschanged(struct ipath_devdata *dd,
		ipath_err_t errs, int noprint)
		ipath_err_t errs)
		{
		u64 val;
		u32 ltstate, lstate;
		u32 ltstate, lstate, ibstate, lastlstate;
		u32 init = dd->ib_init;
		u32 arm = dd->ib_arm;
		u32 active = dd->ib_active;
		const u64 ibcs = ipath_read_kreg64(dd, dd->ipath_kregs->kr_ibcstatus);

		lstate = ipath_ib_linkstate(dd, ibcs); /* linkstate */
		ibstate = ipath_ib_state(dd, ibcs);
		/* linkstate at last interrupt */
		lastlstate = ipath_ib_linkstate(dd, dd->ipath_lastibcstat);
		ltstate = ipath_ib_linktrstate(dd, ibcs); /* linktrainingtate */

		/*
		* even if diags are enabled, we want to notice LINKINIT, etc.
		* We just don't want to change the LED state, or
		* dd->ipath_kregs->kr_ibcctrl
		*/
		val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_ibcstatus);
		lstate = val & IPATH_IBSTATE_MASK;

		/*
		* this is confusing enough when it happens that I want to always put it
		* on the console and in the logs. If it was a requested state change,
		* we'll have already cleared the flags, so we won't print this warning
		*/
		if ((lstate != IPATH_IBSTATE_ARM && lstate != IPATH_IBSTATE_ACTIVE)
		&& (dd->ipath_flags & (IPATH_LINKARMED \| IPATH_LINKACTIVE))) {
		dev_info(&dd->pcidev->dev, "Link state changed from %s to %s\n",
		(dd->ipath_flags & IPATH_LINKARMED) ? "ARM" : "ACTIVE",
		ib_linkstate(lstate));
		/*
		* Flush all queued sends when link went to DOWN or INIT,
		* to be sure that they don't block SMA and other MAD packets
		* if linkstate transitions into INIT from any of the various down
		* states, or if it transitions from any of the up (INIT or better)
		* states into any of the down states (except link recovery), then
		* call the chip-specific code to take appropriate actions.
		*/
		ipath_cancel_sends(dd, 1);
		if (lstate >= INFINIPATH_IBCS_L_STATE_INIT &&
		lastlstate == INFINIPATH_IBCS_L_STATE_DOWN) {
		/* transitioned to UP */
		if (dd->ipath_f_ib_updown(dd, 1, ibcs)) {
		ipath_cdbg(LINKVERB, "LinkUp handled, skipped\n");
		goto skip_ibchange; /* chip-code handled */
		}
		} else if ((lastlstate >= INFINIPATH_IBCS_L_STATE_INIT \|\|
		(dd->ipath_flags & IPATH_IB_FORCE_NOTIFY)) &&
		ltstate <= INFINIPATH_IBCS_LT_STATE_CFGDEBOUNCE &&
		ltstate != INFINIPATH_IBCS_LT_STATE_LINKUP) {
		int handled;
		handled = dd->ipath_f_ib_updown(dd, 0, ibcs);
		dd->ipath_flags &= ~IPATH_IB_FORCE_NOTIFY;
		if (handled) {
		ipath_cdbg(LINKVERB, "LinkDown handled, skipped\n");
		goto skip_ibchange; /* chip-code handled */
		}
		else if (lstate == IPATH_IBSTATE_INIT \|\| lstate == IPATH_IBSTATE_ARM \|\|
		lstate == IPATH_IBSTATE_ACTIVE) {
		}

		/*
		* only print at SMA if there is a change, debug if not
		* (sometimes we want to know that, usually not).
		* Significant enough to always print and get into logs, if it was
		* unexpected. If it was a requested state change, we'll have
		* already cleared the flags, so we won't print this warning
		*/
		if (lstate == ((unsigned) dd->ipath_lastibcstat
		& IPATH_IBSTATE_MASK)) {
		ipath_dbg("Status change intr but no change (%s)\n",
		ib_linkstate(lstate));
		if ((ibstate != arm && ibstate != active) &&
		(dd->ipath_flags & (IPATH_LINKARMED \| IPATH_LINKACTIVE))) {
		dev_info(&dd->pcidev->dev, "Link state changed from %s "
		"to %s\n", (dd->ipath_flags & IPATH_LINKARMED) ?
		"ARM" : "ACTIVE", ib_linkstate(dd, ibcs));
		}
		else
		ipath_cdbg(VERBOSE, "Unit %u link state %s, last "
		"was %s\n", dd->ipath_unit,
		ib_linkstate(lstate),
		ib_linkstate((unsigned)
		dd->ipath_lastibcstat
		& IPATH_IBSTATE_MASK));
		}
		else {
		lstate = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
		if (lstate == IPATH_IBSTATE_INIT \|\|
		lstate == IPATH_IBSTATE_ARM \|\|
		lstate == IPATH_IBSTATE_ACTIVE)
		ipath_cdbg(VERBOSE, "Unit %u link state down"
		" (state 0x%x), from %s\n",
		dd->ipath_unit,
		(u32)val & IPATH_IBSTATE_MASK,
		ib_linkstate(lstate));
		else
		ipath_cdbg(VERBOSE, "Unit %u link state changed "
		"to 0x%x from down (%x)\n",
		dd->ipath_unit, (u32) val, lstate);
		}
		ltstate = (val >> INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKTRAININGSTATE_MASK;
		lstate = (val >> INFINIPATH_IBCS_LINKSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKSTATE_MASK;

		if (ltstate == INFINIPATH_IBCS_LT_STATE_POLLACTIVE \|\|
		ltstate == INFINIPATH_IBCS_LT_STATE_POLLQUIET) {
		u32 last_ltstate;

		u32 lastlts;
		lastlts = ipath_ib_linktrstate(dd, dd->ipath_lastibcstat);
		/*
		* Ignore cycling back and forth from Polling.Active
		* to Polling.Quiet while waiting for the other end of
		* the link to come up. We will cycle back and forth
		* between them if no cable is plugged in,
		* the other device is powered off or disabled, etc.
		* Ignore cycling back and forth from Polling.Active to
		* Polling.Quiet while waiting for the other end of the link
		* to come up, except to try and decide if we are connected
		* to a live IB device or not. We will cycle back and
		* forth between them if no cable is plugged in, the other
		* device is powered off or disabled, etc.
		*/
		last_ltstate = (dd->ipath_lastibcstat >>
		INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT)
		& INFINIPATH_IBCS_LINKTRAININGSTATE_MASK;
		if (last_ltstate == INFINIPATH_IBCS_LT_STATE_POLLACTIVE
		\|\| last_ltstate ==
		INFINIPATH_IBCS_LT_STATE_POLLQUIET) {
		if (dd->ipath_ibpollcnt > 40) {
		if (lastlts == INFINIPATH_IBCS_LT_STATE_POLLACTIVE \|\|
		lastlts == INFINIPATH_IBCS_LT_STATE_POLLQUIET) {
		if (++dd->ipath_ibpollcnt == 40) {
		dd->ipath_flags \|= IPATH_NOCABLE;
		*dd->ipath_statusp \|=
		IPATH_STATUS_IB_NOCABLE;
		} else
		dd->ipath_ibpollcnt++;
		ipath_cdbg(LINKVERB, "Set NOCABLE\n");
		}
		ipath_cdbg(LINKVERB, "POLL change to %s (%x)\n",
		ipath_ibcstatus_str[ltstate], ibstate);
		goto skip_ibchange;
		}
		}
		dd->ipath_ibpollcnt = 0; /* some state other than 2 or 3 */

		dd->ipath_ibpollcnt = 0; /* not poll, now /
		ipath_stats.sps_iblink++;
		if (ltstate != INFINIPATH_IBCS_LT_STATE_LINKUP) {

		if (ibstate == init \|\| ibstate == arm \|\| ibstate == active) {
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_NOCABLE;
		if (ibstate == init \|\| ibstate == arm) {
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_READY;
		if (dd->ipath_flags & IPATH_LINKACTIVE)
		signal_ib_event(dd, IB_EVENT_PORT_ERR);
		dd->ipath_flags \|= IPATH_LINKDOWN;
		dd->ipath_flags &= ~(IPATH_LINKUNK \| IPATH_LINKINIT
		\| IPATH_LINKACTIVE \|
		IPATH_LINKARMED);
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_READY;
		dd->ipath_lli_counter = 0;
		if (!noprint) {
		if (((dd->ipath_lastibcstat >>
		INFINIPATH_IBCS_LINKSTATE_SHIFT) &
		INFINIPATH_IBCS_LINKSTATE_MASK)
		== INFINIPATH_IBCS_L_STATE_ACTIVE)
		/* if from up to down be more vocal */
		ipath_cdbg(VERBOSE,
		"Unit %u link now down (%s)\n",
		dd->ipath_unit,
		ipath_ibcstatus_str[ltstate]);
		else
		ipath_cdbg(VERBOSE, "Unit %u link is "
		"down (%s)\n", dd->ipath_unit,
		ipath_ibcstatus_str[ltstate]);
		}

		dd->ipath_f_setextled(dd, lstate, ltstate);
		} else if ((val & IPATH_IBSTATE_MASK) == IPATH_IBSTATE_ACTIVE) {
		dd->ipath_flags \|= IPATH_LINKACTIVE;
		dd->ipath_flags &=
		~(IPATH_LINKUNK \| IPATH_LINKINIT \| IPATH_LINKDOWN \|
		IPATH_LINKARMED \| IPATH_NOCABLE);
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_NOCABLE;
		if (ibstate == arm) {
		dd->ipath_flags \|= IPATH_LINKARMED;
		dd->ipath_flags &= ~(IPATH_LINKUNK \|
		IPATH_LINKINIT \| IPATH_LINKDOWN \|
		IPATH_LINKACTIVE \| IPATH_NOCABLE);
		ipath_hol_down(dd);
		} else if (ibstate == init) {
		/*
		* set INIT and DOWN. Down is checked by
		* most of the other code, but INIT is
		* useful to know in a few places.
		*/
		dd->ipath_flags \|= IPATH_LINKINIT \|
		IPATH_LINKDOWN;
		dd->ipath_flags &= ~(IPATH_LINKUNK \|
		IPATH_LINKARMED \| IPATH_LINKACTIVE \|
		IPATH_NOCABLE);
		ipath_hol_down(dd);
		} else { /* active */
		*dd->ipath_statusp \|=
		IPATH_STATUS_IB_READY \| IPATH_STATUS_IB_CONF;
		dd->ipath_f_setextled(dd, lstate, ltstate);
		dd->ipath_flags \|= IPATH_LINKACTIVE;
		dd->ipath_flags &= ~(IPATH_LINKUNK \| IPATH_LINKINIT
		\| IPATH_LINKDOWN \| IPATH_LINKARMED \|
		IPATH_NOCABLE);
		signal_ib_event(dd, IB_EVENT_PORT_ACTIVE);
		} else if ((val & IPATH_IBSTATE_MASK) == IPATH_IBSTATE_INIT) {
		if (dd->ipath_flags & IPATH_LINKACTIVE)
		signal_ib_event(dd, IB_EVENT_PORT_ERR);
		/* LED active not handled in chip _f_updown */
		dd->ipath_f_setextled(dd, lstate, ltstate);
		ipath_hol_up(dd);
		}

		/*
		* set INIT and DOWN. Down is checked by most of the other
		* code, but INIT is useful to know in a few places.
		* print after we've already done the work, so as not to
		* delay the state changes and notifications, for debugging
		*/
		dd->ipath_flags \|= IPATH_LINKINIT \| IPATH_LINKDOWN;
		dd->ipath_flags &=
		~(IPATH_LINKUNK \| IPATH_LINKACTIVE \| IPATH_LINKARMED
		\| IPATH_NOCABLE);
		*dd->ipath_statusp &= ~(IPATH_STATUS_IB_NOCABLE
		\| IPATH_STATUS_IB_READY);
		dd->ipath_f_setextled(dd, lstate, ltstate);
		} else if ((val & IPATH_IBSTATE_MASK) == IPATH_IBSTATE_ARM) {
		if (lstate == lastlstate)
		ipath_cdbg(LINKVERB, "Unchanged from last: %s "
		"(%x)\n", ib_linkstate(dd, ibcs), ibstate);
		else
		ipath_cdbg(VERBOSE, "Unit %u: link up to %s %s (%x)\n",
		dd->ipath_unit, ib_linkstate(dd, ibcs),
		ipath_ibcstatus_str[ltstate], ibstate);
		} else { /* down */
		if (dd->ipath_flags & IPATH_LINKACTIVE)
		signal_ib_event(dd, IB_EVENT_PORT_ERR);
		dd->ipath_flags \|= IPATH_LINKARMED;
		dd->ipath_flags &=
		~(IPATH_LINKUNK \| IPATH_LINKDOWN \| IPATH_LINKINIT \|
		IPATH_LINKACTIVE \| IPATH_NOCABLE);
		*dd->ipath_statusp &= ~(IPATH_STATUS_IB_NOCABLE
		\| IPATH_STATUS_IB_READY);
		dd->ipath_f_setextled(dd, lstate, ltstate);
		} else {
		if (!noprint)
		ipath_dbg("IBstatuschange unit %u: %s (%x)\n",
		dd->ipath_flags \|= IPATH_LINKDOWN;
		dd->ipath_flags &= ~(IPATH_LINKUNK \| IPATH_LINKINIT
		\| IPATH_LINKACTIVE \|
		IPATH_LINKARMED);
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_READY;
		dd->ipath_lli_counter = 0;

		if (lastlstate != INFINIPATH_IBCS_L_STATE_DOWN)
		ipath_cdbg(VERBOSE, "Unit %u link state down "
		"(state 0x%x), from %s\n",
		dd->ipath_unit, lstate,
		ib_linkstate(dd, dd->ipath_lastibcstat));
		else
		ipath_cdbg(LINKVERB, "Unit %u link state changed "
		"to %s (0x%x) from down (%x)\n",
		dd->ipath_unit,
		ipath_ibcstatus_str[ltstate], ltstate);
		ipath_ibcstatus_str[ltstate],
		ibstate, lastlstate);
		}

		skip_ibchange:
		dd->ipath_lastibcstat = val;
		dd->ipath_lastibcstat = ibcs;
		}

		static void handle_supp_msgs(struct ipath_devdata *dd,
		@@ -743,16 +731,13 @@ static int handle_errors(struct ipath_devdata *dd, ipath_err_t errs)
		dd->ipath_flags &= ~(IPATH_LINKUNK \| IPATH_LINKINIT
		\| IPATH_LINKARMED \| IPATH_LINKACTIVE);
		*dd->ipath_statusp &= ~IPATH_STATUS_IB_READY;
		if (!noprint) {
		u64 st = ipath_read_kreg64(
		dd, dd->ipath_kregs->kr_ibcstatus);

		ipath_dbg("Lost link, link now down (%s)\n",
		ipath_ibcstatus_str[st & 0xf]);
		}
		ipath_ibcstatus_str[ipath_read_kreg64(dd,
		dd->ipath_kregs->kr_ibcstatus) & 0xf]);
		}
		if (errs & INFINIPATH_E_IBSTATUSCHANGED)
		handle_e_ibstatuschanged(dd, errs, noprint);
		handle_e_ibstatuschanged(dd, errs);

		if (errs & INFINIPATH_E_RESET) {
		if (!noprint)

Admin message