[linux-block.git] / net / ncsi / ncsi-aen.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright Gavin Shan, IBM Corporation 2016.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>

#include <net/ncsi.h>
#include <net/net_namespace.h>
#include <net/sock.h>

#include "internal.h"
#include "ncsi-pkt.h"

static int ncsi_validate_aen_pkt(struct ncsi_aen_pkt_hdr *h,
				 const unsigned short payload)
{
	u32 checksum;
	__be32 *pchecksum;

	if (h->common.revision != NCSI_PKT_REVISION)
		return -EINVAL;
	if (ntohs(h->common.length) != payload)
		return -EINVAL;

	/* Validate checksum, which might be zeroes if the
	 * sender doesn't support checksum according to NCSI
	 * specification.
	 */
	pchecksum = (__be32 *)((void *)(h + 1) + payload - 4);
	if (ntohl(*pchecksum) == 0)
		return 0;

	checksum = ncsi_calculate_checksum((unsigned char *)h,
					   sizeof(*h) + payload - 4);
	if (*pchecksum != htonl(checksum))
		return -EINVAL;

	return 0;
}

static int ncsi_aen_handler_lsc(struct ncsi_dev_priv *ndp,
				struct ncsi_aen_pkt_hdr *h)
{
	struct ncsi_channel *nc, *tmp;
	struct ncsi_channel_mode *ncm;
	unsigned long old_data, data;
	struct ncsi_aen_lsc_pkt *lsc;
	struct ncsi_package *np;
	bool had_link, has_link;
	unsigned long flags;
	bool chained;
	int state;

	/* Find the NCSI channel */
	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	if (!nc)
		return -ENODEV;

	/* Update the link status */
	lsc = (struct ncsi_aen_lsc_pkt *)h;

	spin_lock_irqsave(&nc->lock, flags);
	ncm = &nc->modes[NCSI_MODE_LINK];
	old_data = ncm->data[2];
	data = ntohl(lsc->status);
	ncm->data[2] = data;
	ncm->data[4] = ntohl(lsc->oem_status);

	had_link = !!(old_data & 0x1);
	has_link = !!(data & 0x1);

	netdev_dbg(ndp->ndev.dev, "NCSI: LSC AEN - channel %u state %s\n",
		   nc->id, data & 0x1 ? "up" : "down");

	chained = !list_empty(&nc->link);
	state = nc->state;
	spin_unlock_irqrestore(&nc->lock, flags);

	if (state == NCSI_CHANNEL_INACTIVE)
		netdev_warn(ndp->ndev.dev,
			    "NCSI: Inactive channel %u received AEN!\n",
			    nc->id);

	if ((had_link == has_link) || chained)
		return 0;

	if (!ndp->multi_package && !nc->package->multi_channel) {
		if (had_link) {
			ndp->flags |= NCSI_DEV_RESHUFFLE;
			ncsi_stop_channel_monitor(nc);
			spin_lock_irqsave(&ndp->lock, flags);
			list_add_tail_rcu(&nc->link, &ndp->channel_queue);
			spin_unlock_irqrestore(&ndp->lock, flags);
			return ncsi_process_next_channel(ndp);
		}
		/* Configured channel came up */
		return 0;
	}

	if (had_link) {
		ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
		if (ncsi_channel_is_last(ndp, nc)) {
			/* No channels left, reconfigure */
			return ncsi_reset_dev(&ndp->ndev);
		} else if (ncm->enable) {
			/* Need to failover Tx channel */
			ncsi_update_tx_channel(ndp, nc->package, nc, NULL);
		}
	} else if (has_link && nc->package->preferred_channel == nc) {
		/* Return Tx to preferred channel */
		ncsi_update_tx_channel(ndp, nc->package, NULL, nc);
	} else if (has_link) {
		NCSI_FOR_EACH_PACKAGE(ndp, np) {
			NCSI_FOR_EACH_CHANNEL(np, tmp) {
				/* Enable Tx on this channel if the current Tx
				 * channel is down.
				 */
				ncm = &tmp->modes[NCSI_MODE_TX_ENABLE];
				if (ncm->enable &&
				    !ncsi_channel_has_link(tmp)) {
					ncsi_update_tx_channel(ndp, nc->package,
							       tmp, nc);
					break;
				}
			}
		}
	}

	/* Leave configured channels active in a multi-channel scenario so
	 * AEN events are still received.
	 */
	return 0;
}

static int ncsi_aen_handler_cr(struct ncsi_dev_priv *ndp,
			       struct ncsi_aen_pkt_hdr *h)
{
	struct ncsi_channel *nc;
	unsigned long flags;

	/* Find the NCSI channel */
	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	if (!nc)
		return -ENODEV;

	spin_lock_irqsave(&nc->lock, flags);
	if (!list_empty(&nc->link) ||
	    nc->state != NCSI_CHANNEL_ACTIVE) {
		spin_unlock_irqrestore(&nc->lock, flags);
		return 0;
	}
	spin_unlock_irqrestore(&nc->lock, flags);

	ncsi_stop_channel_monitor(nc);
	spin_lock_irqsave(&nc->lock, flags);
	nc->state = NCSI_CHANNEL_INVISIBLE;
	spin_unlock_irqrestore(&nc->lock, flags);

	spin_lock_irqsave(&ndp->lock, flags);
	nc->state = NCSI_CHANNEL_INACTIVE;
	list_add_tail_rcu(&nc->link, &ndp->channel_queue);
	spin_unlock_irqrestore(&ndp->lock, flags);
	nc->modes[NCSI_MODE_TX_ENABLE].enable = 0;

	return ncsi_process_next_channel(ndp);
}

static int ncsi_aen_handler_hncdsc(struct ncsi_dev_priv *ndp,
				   struct ncsi_aen_pkt_hdr *h)
{
	struct ncsi_channel *nc;
	struct ncsi_channel_mode *ncm;
	struct ncsi_aen_hncdsc_pkt *hncdsc;
	unsigned long flags;

	/* Find the NCSI channel */
	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	if (!nc)
		return -ENODEV;

	spin_lock_irqsave(&nc->lock, flags);
	ncm = &nc->modes[NCSI_MODE_LINK];
	hncdsc = (struct ncsi_aen_hncdsc_pkt *)h;
	ncm->data[3] = ntohl(hncdsc->status);
	spin_unlock_irqrestore(&nc->lock, flags);
	netdev_dbg(ndp->ndev.dev,
		   "NCSI: host driver %srunning on channel %u\n",
		   ncm->data[3] & 0x1 ? "" : "not ", nc->id);

	return 0;
}

static struct ncsi_aen_handler {
	unsigned char type;
	int           payload;
	int           (*handler)(struct ncsi_dev_priv *ndp,
				 struct ncsi_aen_pkt_hdr *h);
} ncsi_aen_handlers[] = {
	{ NCSI_PKT_AEN_LSC,    12, ncsi_aen_handler_lsc    },
	{ NCSI_PKT_AEN_CR,      4, ncsi_aen_handler_cr     },
	{ NCSI_PKT_AEN_HNCDSC,  8, ncsi_aen_handler_hncdsc }
};

int ncsi_aen_handler(struct ncsi_dev_priv *ndp, struct sk_buff *skb)
{
	struct ncsi_aen_pkt_hdr *h;
	struct ncsi_aen_handler *nah = NULL;
	int i, ret;

	/* Find the handler */
	h = (struct ncsi_aen_pkt_hdr *)skb_network_header(skb);
	for (i = 0; i < ARRAY_SIZE(ncsi_aen_handlers); i++) {
		if (ncsi_aen_handlers[i].type == h->type) {
			nah = &ncsi_aen_handlers[i];
			break;
		}
	}

	if (!nah) {
		netdev_warn(ndp->ndev.dev, "Invalid AEN (0x%x) received\n",
			    h->type);
		return -ENOENT;
	}

	ret = ncsi_validate_aen_pkt(h, nah->payload);
	if (ret) {
		netdev_warn(ndp->ndev.dev,
			    "NCSI: 'bad' packet ignored for AEN type 0x%x\n",
			    h->type);
		goto out;
	}

	ret = nah->handler(ndp, h);
	if (ret)
		netdev_err(ndp->ndev.dev,
			   "NCSI: Handler for AEN type 0x%x returned %d\n",
			   h->type, ret);
out:
	consume_skb(skb);
	return ret;
}
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
7a82ecf4 GS	2	/*
7a82ecf4 GS	3	* Copyright Gavin Shan, IBM Corporation 2016.
7a82ecf4 GS	4	*/
	5
	6	#include <linux/module.h>
	7	#include <linux/kernel.h>
	8	#include <linux/init.h>
	9	#include <linux/netdevice.h>
	10	#include <linux/skbuff.h>
	11
	12	#include <net/ncsi.h>
	13	#include <net/net_namespace.h>
	14	#include <net/sock.h>
	15
	16	#include "internal.h"
	17	#include "ncsi-pkt.h"
	18
	19	static int ncsi_validate_aen_pkt(struct ncsi_aen_pkt_hdr *h,
	20	const unsigned short payload)
	21	{
	22	u32 checksum;
	23	__be32 *pchecksum;
	24
	25	if (h->common.revision != NCSI_PKT_REVISION)
	26	return -EINVAL;
	27	if (ntohs(h->common.length) != payload)
	28	return -EINVAL;
	29
	30	/* Validate checksum, which might be zeroes if the
	31	* sender doesn't support checksum according to NCSI
	32	* specification.
	33	*/
	34	pchecksum = (__be32 )((void )(h + 1) + payload - 4);
	35	if (ntohl(*pchecksum) == 0)
	36	return 0;
	37
	38	checksum = ncsi_calculate_checksum((unsigned char *)h,
	39	sizeof(*h) + payload - 4);
	40	if (*pchecksum != htonl(checksum))
	41	return -EINVAL;
	42
	43	return 0;
	44	}
	45
	46	static int ncsi_aen_handler_lsc(struct ncsi_dev_priv *ndp,
	47	struct ncsi_aen_pkt_hdr *h)
	48	{
8d951a75	49	struct ncsi_channel nc, tmp;
7a82ecf4	50	struct ncsi_channel_mode *ncm;
d8cedaab	51	unsigned long old_data, data;
8d951a75 SMJ	52	struct ncsi_aen_lsc_pkt *lsc;
8d951a75 SMJ	53	struct ncsi_package *np;
0b970e1b	54	bool had_link, has_link;
8d951a75 SMJ	55	unsigned long flags;
	56	bool chained;
	57	int state;
7a82ecf4 GS	58
	59	/* Find the NCSI channel */
	60	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	61	if (!nc)
	62	return -ENODEV;
	63
	64	/* Update the link status */
7a82ecf4	65	lsc = (struct ncsi_aen_lsc_pkt *)h;
d8cedaab GS	66
	67	spin_lock_irqsave(&nc->lock, flags);
	68	ncm = &nc->modes[NCSI_MODE_LINK];
7a82ecf4	69	old_data = ncm->data[2];
d8cedaab GS	70	data = ntohl(lsc->status);
d8cedaab GS	71	ncm->data[2] = data;
7a82ecf4	72	ncm->data[4] = ntohl(lsc->oem_status);
d8cedaab	73
0b970e1b SMJ	74	had_link = !!(old_data & 0x1);
	75	has_link = !!(data & 0x1);
	76
87975a01 JS	77	netdev_dbg(ndp->ndev.dev, "NCSI: LSC AEN - channel %u state %s\n",
87975a01 JS	78	nc->id, data & 0x1 ? "up" : "down");
9ef8690b	79
d8cedaab GS	80	chained = !list_empty(&nc->link);
	81	state = nc->state;
	82	spin_unlock_irqrestore(&nc->lock, flags);
	83
0b970e1b SMJ	84	if (state == NCSI_CHANNEL_INACTIVE)
	85	netdev_warn(ndp->ndev.dev,
	86	"NCSI: Inactive channel %u received AEN!\n",
	87	nc->id);
	88
	89	if ((had_link == has_link) \|\| chained)
7a82ecf4 GS	90	return 0;
7a82ecf4 GS	91
8d951a75 SMJ	92	if (!ndp->multi_package && !nc->package->multi_channel) {
	93	if (had_link) {
	94	ndp->flags \|= NCSI_DEV_RESHUFFLE;
	95	ncsi_stop_channel_monitor(nc);
	96	spin_lock_irqsave(&ndp->lock, flags);
	97	list_add_tail_rcu(&nc->link, &ndp->channel_queue);
	98	spin_unlock_irqrestore(&ndp->lock, flags);
	99	return ncsi_process_next_channel(ndp);
	100	}
	101	/* Configured channel came up */
	102	return 0;
	103	}
7a82ecf4	104
8d951a75 SMJ	105	if (had_link) {
	106	ncm = &nc->modes[NCSI_MODE_TX_ENABLE];
	107	if (ncsi_channel_is_last(ndp, nc)) {
	108	/* No channels left, reconfigure */
	109	return ncsi_reset_dev(&ndp->ndev);
	110	} else if (ncm->enable) {
	111	/* Need to failover Tx channel */
	112	ncsi_update_tx_channel(ndp, nc->package, nc, NULL);
	113	}
	114	} else if (has_link && nc->package->preferred_channel == nc) {
	115	/* Return Tx to preferred channel */
	116	ncsi_update_tx_channel(ndp, nc->package, NULL, nc);
	117	} else if (has_link) {
	118	NCSI_FOR_EACH_PACKAGE(ndp, np) {
	119	NCSI_FOR_EACH_CHANNEL(np, tmp) {
	120	/* Enable Tx on this channel if the current Tx
	121	* channel is down.
	122	*/
	123	ncm = &tmp->modes[NCSI_MODE_TX_ENABLE];
	124	if (ncm->enable &&
	125	!ncsi_channel_has_link(tmp)) {
	126	ncsi_update_tx_channel(ndp, nc->package,
	127	tmp, nc);
	128	break;
	129	}
	130	}
	131	}
	132	}
	133
	134	/* Leave configured channels active in a multi-channel scenario so
	135	* AEN events are still received.
	136	*/
	137	return 0;
7a82ecf4 GS	138	}
	139
	140	static int ncsi_aen_handler_cr(struct ncsi_dev_priv *ndp,
	141	struct ncsi_aen_pkt_hdr *h)
	142	{
	143	struct ncsi_channel *nc;
	144	unsigned long flags;
	145
	146	/* Find the NCSI channel */
	147	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	148	if (!nc)
	149	return -ENODEV;
	150
d8cedaab	151	spin_lock_irqsave(&nc->lock, flags);
7a82ecf4	152	if (!list_empty(&nc->link) \|\|
d8cedaab GS	153	nc->state != NCSI_CHANNEL_ACTIVE) {
d8cedaab GS	154	spin_unlock_irqrestore(&nc->lock, flags);
7a82ecf4	155	return 0;
d8cedaab GS	156	}
d8cedaab GS	157	spin_unlock_irqrestore(&nc->lock, flags);
7a82ecf4 GS	158
7a82ecf4 GS	159	ncsi_stop_channel_monitor(nc);
d8cedaab GS	160	spin_lock_irqsave(&nc->lock, flags);
	161	nc->state = NCSI_CHANNEL_INVISIBLE;
	162	spin_unlock_irqrestore(&nc->lock, flags);
	163
7a82ecf4	164	spin_lock_irqsave(&ndp->lock, flags);
d8cedaab	165	nc->state = NCSI_CHANNEL_INACTIVE;
7a82ecf4 GS	166	list_add_tail_rcu(&nc->link, &ndp->channel_queue);
7a82ecf4 GS	167	spin_unlock_irqrestore(&ndp->lock, flags);
6f75cd16	168	nc->modes[NCSI_MODE_TX_ENABLE].enable = 0;
7a82ecf4 GS	169
	170	return ncsi_process_next_channel(ndp);
	171	}
	172
	173	static int ncsi_aen_handler_hncdsc(struct ncsi_dev_priv *ndp,
	174	struct ncsi_aen_pkt_hdr *h)
	175	{
	176	struct ncsi_channel *nc;
	177	struct ncsi_channel_mode *ncm;
	178	struct ncsi_aen_hncdsc_pkt *hncdsc;
	179	unsigned long flags;
	180
	181	/* Find the NCSI channel */
	182	ncsi_find_package_and_channel(ndp, h->common.channel, NULL, &nc);
	183	if (!nc)
	184	return -ENODEV;
	185
22d8aa93	186	spin_lock_irqsave(&nc->lock, flags);
7a82ecf4 GS	187	ncm = &nc->modes[NCSI_MODE_LINK];
	188	hncdsc = (struct ncsi_aen_hncdsc_pkt *)h;
	189	ncm->data[3] = ntohl(hncdsc->status);
22d8aa93	190	spin_unlock_irqrestore(&nc->lock, flags);
6e42a3f5 JS	191	netdev_dbg(ndp->ndev.dev,
	192	"NCSI: host driver %srunning on channel %u\n",
	193	ncm->data[3] & 0x1 ? "" : "not ", nc->id);
7a82ecf4 GS	194
	195	return 0;
	196	}
	197
	198	static struct ncsi_aen_handler {
	199	unsigned char type;
	200	int payload;
	201	int (handler)(struct ncsi_dev_priv ndp,
	202	struct ncsi_aen_pkt_hdr *h);
	203	} ncsi_aen_handlers[] = {
	204	{ NCSI_PKT_AEN_LSC, 12, ncsi_aen_handler_lsc },
	205	{ NCSI_PKT_AEN_CR, 4, ncsi_aen_handler_cr },
6850d0f8	206	{ NCSI_PKT_AEN_HNCDSC, 8, ncsi_aen_handler_hncdsc }
7a82ecf4 GS	207	};
	208
	209	int ncsi_aen_handler(struct ncsi_dev_priv ndp, struct sk_buff skb)
	210	{
	211	struct ncsi_aen_pkt_hdr *h;
	212	struct ncsi_aen_handler *nah = NULL;
	213	int i, ret;
	214
	215	/* Find the handler */
	216	h = (struct ncsi_aen_pkt_hdr *)skb_network_header(skb);
	217	for (i = 0; i < ARRAY_SIZE(ncsi_aen_handlers); i++) {
	218	if (ncsi_aen_handlers[i].type == h->type) {
	219	nah = &ncsi_aen_handlers[i];
	220	break;
	221	}
	222	}
	223
	224	if (!nah) {
	225	netdev_warn(ndp->ndev.dev, "Invalid AEN (0x%x) received\n",
	226	h->type);
	227	return -ENOENT;
	228	}
	229
	230	ret = ncsi_validate_aen_pkt(h, nah->payload);
9ef8690b SMJ	231	if (ret) {
	232	netdev_warn(ndp->ndev.dev,
	233	"NCSI: 'bad' packet ignored for AEN type 0x%x\n",
	234	h->type);
7a82ecf4	235	goto out;
9ef8690b	236	}
7a82ecf4 GS	237
7a82ecf4 GS	238	ret = nah->handler(ndp, h);
9ef8690b SMJ	239	if (ret)
	240	netdev_err(ndp->ndev.dev,
	241	"NCSI: Handler for AEN type 0x%x returned %d\n",
	242	h->type, ret);
7a82ecf4 GS	243	out:
	244	consume_skb(skb);
	245	return ret;
	246	}