[mirror_ubuntu-focal-kernel.git] / drivers / net / ethernet / cisco / enic / enic_clsf.c

// SPDX-License-Identifier: GPL-2.0
#include <linux/if.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/netdevice.h>
#include <linux/in.h>
#include <linux/types.h>
#include <linux/skbuff.h>
#include <net/flow_dissector.h>
#include "enic_res.h"
#include "enic_clsf.h"

/* enic_addfltr_5t - Add ipv4 5tuple filter
 *	@enic: enic struct of vnic
 *	@keys: flow_keys of ipv4 5tuple
 *	@rq: rq number to steer to
 *
 * This function returns filter_id(hardware_id) of the filter
 * added. In case of error it returns a negative number.
 */
int enic_addfltr_5t(struct enic *enic, struct flow_keys *keys, u16 rq)
{
	int res;
	struct filter data;

	switch (keys->basic.ip_proto) {
	case IPPROTO_TCP:
		data.u.ipv4.protocol = PROTO_TCP;
		break;
	case IPPROTO_UDP:
		data.u.ipv4.protocol = PROTO_UDP;
		break;
	default:
		return -EPROTONOSUPPORT;
	};
	data.type = FILTER_IPV4_5TUPLE;
	data.u.ipv4.src_addr = ntohl(keys->addrs.v4addrs.src);
	data.u.ipv4.dst_addr = ntohl(keys->addrs.v4addrs.dst);
	data.u.ipv4.src_port = ntohs(keys->ports.src);
	data.u.ipv4.dst_port = ntohs(keys->ports.dst);
	data.u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;

	spin_lock_bh(&enic->devcmd_lock);
	res = vnic_dev_classifier(enic->vdev, CLSF_ADD, &rq, &data);
	spin_unlock_bh(&enic->devcmd_lock);
	res = (res == 0) ? rq : res;

	return res;
}

/* enic_delfltr - Delete clsf filter
 *	@enic: enic struct of vnic
 *	@filter_id: filter_is(hardware_id) of filter to be deleted
 *
 * This function returns zero in case of success, negative number incase of
 * error.
 */
int enic_delfltr(struct enic *enic, u16 filter_id)
{
	int ret;

	spin_lock_bh(&enic->devcmd_lock);
	ret = vnic_dev_classifier(enic->vdev, CLSF_DEL, &filter_id, NULL);
	spin_unlock_bh(&enic->devcmd_lock);

	return ret;
}

/* enic_rfs_flw_tbl_init - initialize enic->rfs_h members
 *	@enic: enic data
 */
void enic_rfs_flw_tbl_init(struct enic *enic)
{
	int i;

	spin_lock_init(&enic->rfs_h.lock);
	for (i = 0; i <= ENIC_RFS_FLW_MASK; i++)
		INIT_HLIST_HEAD(&enic->rfs_h.ht_head[i]);
	enic->rfs_h.max = enic->config.num_arfs;
	enic->rfs_h.free = enic->rfs_h.max;
	enic->rfs_h.toclean = 0;
	enic_rfs_timer_start(enic);
}

void enic_rfs_flw_tbl_free(struct enic *enic)
{
	int i;

	enic_rfs_timer_stop(enic);
	spin_lock_bh(&enic->rfs_h.lock);
	enic->rfs_h.free = 0;
	for (i = 0; i < (1 << ENIC_RFS_FLW_BITSHIFT); i++) {
		struct hlist_head *hhead;
		struct hlist_node *tmp;
		struct enic_rfs_fltr_node *n;

		hhead = &enic->rfs_h.ht_head[i];
		hlist_for_each_entry_safe(n, tmp, hhead, node) {
			enic_delfltr(enic, n->fltr_id);
			hlist_del(&n->node);
			kfree(n);
		}
	}
	spin_unlock_bh(&enic->rfs_h.lock);
}

struct enic_rfs_fltr_node *htbl_fltr_search(struct enic *enic, u16 fltr_id)
{
	int i;

	for (i = 0; i < (1 << ENIC_RFS_FLW_BITSHIFT); i++) {
		struct hlist_head *hhead;
		struct hlist_node *tmp;
		struct enic_rfs_fltr_node *n;

		hhead = &enic->rfs_h.ht_head[i];
		hlist_for_each_entry_safe(n, tmp, hhead, node)
			if (n->fltr_id == fltr_id)
				return n;
	}

	return NULL;
}

#ifdef CONFIG_RFS_ACCEL
void enic_flow_may_expire(unsigned long data)
{
	struct enic *enic = (struct enic *)data;
	bool res;
	int j;

	spin_lock_bh(&enic->rfs_h.lock);
	for (j = 0; j < ENIC_CLSF_EXPIRE_COUNT; j++) {
		struct hlist_head *hhead;
		struct hlist_node *tmp;
		struct enic_rfs_fltr_node *n;

		hhead = &enic->rfs_h.ht_head[enic->rfs_h.toclean++];
		hlist_for_each_entry_safe(n, tmp, hhead, node) {
			res = rps_may_expire_flow(enic->netdev, n->rq_id,
						  n->flow_id, n->fltr_id);
			if (res) {
				res = enic_delfltr(enic, n->fltr_id);
				if (unlikely(res))
					continue;
				hlist_del(&n->node);
				kfree(n);
				enic->rfs_h.free++;
			}
		}
	}
	spin_unlock_bh(&enic->rfs_h.lock);
	mod_timer(&enic->rfs_h.rfs_may_expire, jiffies + HZ/4);
}

static struct enic_rfs_fltr_node *htbl_key_search(struct hlist_head *h,
						  struct flow_keys *k)
{
	struct enic_rfs_fltr_node *tpos;

	hlist_for_each_entry(tpos, h, node)
		if (tpos->keys.addrs.v4addrs.src == k->addrs.v4addrs.src &&
		    tpos->keys.addrs.v4addrs.dst == k->addrs.v4addrs.dst &&
		    tpos->keys.ports.ports == k->ports.ports &&
		    tpos->keys.basic.ip_proto == k->basic.ip_proto &&
		    tpos->keys.basic.n_proto == k->basic.n_proto)
			return tpos;
	return NULL;
}

int enic_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb,
		       u16 rxq_index, u32 flow_id)
{
	struct flow_keys keys;
	struct enic_rfs_fltr_node *n;
	struct enic *enic;
	u16 tbl_idx;
	int res, i;

	enic = netdev_priv(dev);
	res = skb_flow_dissect_flow_keys(skb, &keys, 0);
	if (!res || keys.basic.n_proto != htons(ETH_P_IP) ||
	    (keys.basic.ip_proto != IPPROTO_TCP &&
	     keys.basic.ip_proto != IPPROTO_UDP))
		return -EPROTONOSUPPORT;

	tbl_idx = skb_get_hash_raw(skb) & ENIC_RFS_FLW_MASK;
	spin_lock_bh(&enic->rfs_h.lock);
	n = htbl_key_search(&enic->rfs_h.ht_head[tbl_idx], &keys);

	if (n) { /* entry already present  */
		if (rxq_index == n->rq_id) {
			res = -EEXIST;
			goto ret_unlock;
		}

		/* desired rq changed for the flow, we need to delete
		 * old fltr and add new one
		 *
		 * The moment we delete the fltr, the upcoming pkts
		 * are put it default rq based on rss. When we add
		 * new filter, upcoming pkts are put in desired queue.
		 * This could cause ooo pkts.
		 *
		 * Lets 1st try adding new fltr and then del old one.
		 */
		i = --enic->rfs_h.free;
		/* clsf tbl is full, we have to del old fltr first*/
		if (unlikely(i < 0)) {
			enic->rfs_h.free++;
			res = enic_delfltr(enic, n->fltr_id);
			if (unlikely(res < 0))
				goto ret_unlock;
			res = enic_addfltr_5t(enic, &keys, rxq_index);
			if (res < 0) {
				hlist_del(&n->node);
				enic->rfs_h.free++;
				goto ret_unlock;
			}
		/* add new fltr 1st then del old fltr */
		} else {
			int ret;

			res = enic_addfltr_5t(enic, &keys, rxq_index);
			if (res < 0) {
				enic->rfs_h.free++;
				goto ret_unlock;
			}
			ret = enic_delfltr(enic, n->fltr_id);
			/* deleting old fltr failed. Add old fltr to list.
			 * enic_flow_may_expire() will try to delete it later.
			 */
			if (unlikely(ret < 0)) {
				struct enic_rfs_fltr_node *d;
				struct hlist_head *head;

				head = &enic->rfs_h.ht_head[tbl_idx];
				d = kmalloc(sizeof(*d), GFP_ATOMIC);
				if (d) {
					d->fltr_id = n->fltr_id;
					INIT_HLIST_NODE(&d->node);
					hlist_add_head(&d->node, head);
				}
			} else {
				enic->rfs_h.free++;
			}
		}
		n->rq_id = rxq_index;
		n->fltr_id = res;
		n->flow_id = flow_id;
	/* entry not present */
	} else {
		i = --enic->rfs_h.free;
		if (i <= 0) {
			enic->rfs_h.free++;
			res = -EBUSY;
			goto ret_unlock;
		}

		n = kmalloc(sizeof(*n), GFP_ATOMIC);
		if (!n) {
			res = -ENOMEM;
			enic->rfs_h.free++;
			goto ret_unlock;
		}

		res = enic_addfltr_5t(enic, &keys, rxq_index);
		if (res < 0) {
			kfree(n);
			enic->rfs_h.free++;
			goto ret_unlock;
		}
		n->rq_id = rxq_index;
		n->fltr_id = res;
		n->flow_id = flow_id;
		n->keys = keys;
		INIT_HLIST_NODE(&n->node);
		hlist_add_head(&n->node, &enic->rfs_h.ht_head[tbl_idx]);
	}

ret_unlock:
	spin_unlock_bh(&enic->rfs_h.lock);
	return res;
}

#endif /* CONFIG_RFS_ACCEL */
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
63118527 GV	2	#include <linux/if.h>
	3	#include <linux/if_ether.h>
	4	#include <linux/if_link.h>
	5	#include <linux/netdevice.h>
	6	#include <linux/in.h>
	7	#include <linux/types.h>
	8	#include <linux/skbuff.h>
1bd758eb	9	#include <net/flow_dissector.h>
63118527 GV	10	#include "enic_res.h"
	11	#include "enic_clsf.h"
	12
	13	/* enic_addfltr_5t - Add ipv4 5tuple filter
	14	* @enic: enic struct of vnic
	15	* @keys: flow_keys of ipv4 5tuple
	16	* @rq: rq number to steer to
	17	*
	18	* This function returns filter_id(hardware_id) of the filter
29044b58	19	* added. In case of error it returns a negative number.
63118527 GV	20	*/
	21	int enic_addfltr_5t(struct enic enic, struct flow_keys keys, u16 rq)
	22	{
	23	int res;
	24	struct filter data;
	25
06635a35	26	switch (keys->basic.ip_proto) {
63118527 GV	27	case IPPROTO_TCP:
	28	data.u.ipv4.protocol = PROTO_TCP;
	29	break;
	30	case IPPROTO_UDP:
	31	data.u.ipv4.protocol = PROTO_UDP;
	32	break;
	33	default:
	34	return -EPROTONOSUPPORT;
	35	};
	36	data.type = FILTER_IPV4_5TUPLE;
c3f83241 TH	37	data.u.ipv4.src_addr = ntohl(keys->addrs.v4addrs.src);
c3f83241 TH	38	data.u.ipv4.dst_addr = ntohl(keys->addrs.v4addrs.dst);
59346afe JP	39	data.u.ipv4.src_port = ntohs(keys->ports.src);
59346afe JP	40	data.u.ipv4.dst_port = ntohs(keys->ports.dst);
63118527 GV	41	data.u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
	42
	43	spin_lock_bh(&enic->devcmd_lock);
	44	res = vnic_dev_classifier(enic->vdev, CLSF_ADD, &rq, &data);
	45	spin_unlock_bh(&enic->devcmd_lock);
	46	res = (res == 0) ? rq : res;
	47
	48	return res;
	49	}
	50
	51	/* enic_delfltr - Delete clsf filter
	52	* @enic: enic struct of vnic
	53	* @filter_id: filter_is(hardware_id) of filter to be deleted
	54	*
	55	* This function returns zero in case of success, negative number incase of
	56	* error.
	57	*/
	58	int enic_delfltr(struct enic *enic, u16 filter_id)
	59	{
	60	int ret;
	61
	62	spin_lock_bh(&enic->devcmd_lock);
	63	ret = vnic_dev_classifier(enic->vdev, CLSF_DEL, &filter_id, NULL);
	64	spin_unlock_bh(&enic->devcmd_lock);
	65
	66	return ret;
	67	}
a145df23	68
a145df23 GV	69	/* enic_rfs_flw_tbl_init - initialize enic->rfs_h members
	70	* @enic: enic data
	71	*/
	72	void enic_rfs_flw_tbl_init(struct enic *enic)
	73	{
	74	int i;
	75
	76	spin_lock_init(&enic->rfs_h.lock);
	77	for (i = 0; i <= ENIC_RFS_FLW_MASK; i++)
	78	INIT_HLIST_HEAD(&enic->rfs_h.ht_head[i]);
	79	enic->rfs_h.max = enic->config.num_arfs;
	80	enic->rfs_h.free = enic->rfs_h.max;
	81	enic->rfs_h.toclean = 0;
e3e5af33	82	enic_rfs_timer_start(enic);
a145df23 GV	83	}
	84
	85	void enic_rfs_flw_tbl_free(struct enic *enic)
	86	{
f2769af9	87	int i;
a145df23	88
e3e5af33	89	enic_rfs_timer_stop(enic);
b6931c9b	90	spin_lock_bh(&enic->rfs_h.lock);
a145df23 GV	91	enic->rfs_h.free = 0;
	92	for (i = 0; i < (1 << ENIC_RFS_FLW_BITSHIFT); i++) {
	93	struct hlist_head *hhead;
	94	struct hlist_node *tmp;
	95	struct enic_rfs_fltr_node *n;
	96
	97	hhead = &enic->rfs_h.ht_head[i];
	98	hlist_for_each_entry_safe(n, tmp, hhead, node) {
	99	enic_delfltr(enic, n->fltr_id);
	100	hlist_del(&n->node);
	101	kfree(n);
	102	}
	103	}
b6931c9b	104	spin_unlock_bh(&enic->rfs_h.lock);
a145df23 GV	105	}
a145df23 GV	106
3762ff8f GV	107	struct enic_rfs_fltr_node htbl_fltr_search(struct enic enic, u16 fltr_id)
	108	{
	109	int i;
	110
	111	for (i = 0; i < (1 << ENIC_RFS_FLW_BITSHIFT); i++) {
	112	struct hlist_head *hhead;
	113	struct hlist_node *tmp;
	114	struct enic_rfs_fltr_node *n;
	115
	116	hhead = &enic->rfs_h.ht_head[i];
	117	hlist_for_each_entry_safe(n, tmp, hhead, node)
	118	if (n->fltr_id == fltr_id)
	119	return n;
	120	}
	121
	122	return NULL;
	123	}
	124
e3e5af33 GV	125	#ifdef CONFIG_RFS_ACCEL
	126	void enic_flow_may_expire(unsigned long data)
	127	{
	128	struct enic enic = (struct enic )data;
	129	bool res;
	130	int j;
	131
b6931c9b	132	spin_lock_bh(&enic->rfs_h.lock);
e3e5af33 GV	133	for (j = 0; j < ENIC_CLSF_EXPIRE_COUNT; j++) {
	134	struct hlist_head *hhead;
	135	struct hlist_node *tmp;
	136	struct enic_rfs_fltr_node *n;
	137
	138	hhead = &enic->rfs_h.ht_head[enic->rfs_h.toclean++];
	139	hlist_for_each_entry_safe(n, tmp, hhead, node) {
	140	res = rps_may_expire_flow(enic->netdev, n->rq_id,
	141	n->flow_id, n->fltr_id);
	142	if (res) {
	143	res = enic_delfltr(enic, n->fltr_id);
	144	if (unlikely(res))
	145	continue;
	146	hlist_del(&n->node);
	147	kfree(n);
	148	enic->rfs_h.free++;
	149	}
	150	}
	151	}
b6931c9b	152	spin_unlock_bh(&enic->rfs_h.lock);
e3e5af33 GV	153	mod_timer(&enic->rfs_h.rfs_may_expire, jiffies + HZ/4);
	154	}
	155
a145df23 GV	156	static struct enic_rfs_fltr_node htbl_key_search(struct hlist_head h,
	157	struct flow_keys *k)
	158	{
	159	struct enic_rfs_fltr_node *tpos;
	160
	161	hlist_for_each_entry(tpos, h, node)
c3f83241 TH	162	if (tpos->keys.addrs.v4addrs.src == k->addrs.v4addrs.src &&
c3f83241 TH	163	tpos->keys.addrs.v4addrs.dst == k->addrs.v4addrs.dst &&
06635a35 JP	164	tpos->keys.ports.ports == k->ports.ports &&
	165	tpos->keys.basic.ip_proto == k->basic.ip_proto &&
	166	tpos->keys.basic.n_proto == k->basic.n_proto)
a145df23 GV	167	return tpos;
	168	return NULL;
	169	}
	170
	171	int enic_rx_flow_steer(struct net_device dev, const struct sk_buff skb,
	172	u16 rxq_index, u32 flow_id)
	173	{
	174	struct flow_keys keys;
	175	struct enic_rfs_fltr_node *n;
	176	struct enic *enic;
	177	u16 tbl_idx;
	178	int res, i;
	179
	180	enic = netdev_priv(dev);
cd79a238	181	res = skb_flow_dissect_flow_keys(skb, &keys, 0);
06635a35 JP	182	if (!res \|\| keys.basic.n_proto != htons(ETH_P_IP) \|\|
	183	(keys.basic.ip_proto != IPPROTO_TCP &&
	184	keys.basic.ip_proto != IPPROTO_UDP))
a145df23 GV	185	return -EPROTONOSUPPORT;
	186
	187	tbl_idx = skb_get_hash_raw(skb) & ENIC_RFS_FLW_MASK;
b6931c9b	188	spin_lock_bh(&enic->rfs_h.lock);
a145df23 GV	189	n = htbl_key_search(&enic->rfs_h.ht_head[tbl_idx], &keys);
	190
	191	if (n) { /* entry already present */
	192	if (rxq_index == n->rq_id) {
	193	res = -EEXIST;
	194	goto ret_unlock;
	195	}
	196
	197	/* desired rq changed for the flow, we need to delete
	198	* old fltr and add new one
	199	*
	200	* The moment we delete the fltr, the upcoming pkts
	201	* are put it default rq based on rss. When we add
	202	* new filter, upcoming pkts are put in desired queue.
	203	* This could cause ooo pkts.
	204	*
	205	* Lets 1st try adding new fltr and then del old one.
	206	*/
	207	i = --enic->rfs_h.free;
	208	/* clsf tbl is full, we have to del old fltr first*/
	209	if (unlikely(i < 0)) {
	210	enic->rfs_h.free++;
	211	res = enic_delfltr(enic, n->fltr_id);
	212	if (unlikely(res < 0))
	213	goto ret_unlock;
	214	res = enic_addfltr_5t(enic, &keys, rxq_index);
	215	if (res < 0) {
	216	hlist_del(&n->node);
	217	enic->rfs_h.free++;
	218	goto ret_unlock;
	219	}
	220	/* add new fltr 1st then del old fltr */
	221	} else {
	222	int ret;
	223
	224	res = enic_addfltr_5t(enic, &keys, rxq_index);
	225	if (res < 0) {
	226	enic->rfs_h.free++;
	227	goto ret_unlock;
	228	}
	229	ret = enic_delfltr(enic, n->fltr_id);
	230	/* deleting old fltr failed. Add old fltr to list.
	231	* enic_flow_may_expire() will try to delete it later.
	232	*/
	233	if (unlikely(ret < 0)) {
	234	struct enic_rfs_fltr_node *d;
	235	struct hlist_head *head;
	236
	237	head = &enic->rfs_h.ht_head[tbl_idx];
	238	d = kmalloc(sizeof(*d), GFP_ATOMIC);
	239	if (d) {
	240	d->fltr_id = n->fltr_id;
	241	INIT_HLIST_NODE(&d->node);
	242	hlist_add_head(&d->node, head);
	243	}
	244	} else {
	245	enic->rfs_h.free++;
	246	}
	247	}
	248	n->rq_id = rxq_index;
	249	n->fltr_id = res;
	250	n->flow_id = flow_id;
	251	/* entry not present */
	252	} else {
253	i = --enic->rfs_h.free;
254	if (i <= 0) {
255	enic->rfs_h.free++;
256	res = -EBUSY;
257	goto ret_unlock;
258	}
259
260	n = kmalloc(sizeof(*n), GFP_ATOMIC);
261	if (!n) {
262	res = -ENOMEM;
263	enic->rfs_h.free++;
264	goto ret_unlock;
265	}
266
267	res = enic_addfltr_5t(enic, &keys, rxq_index);
268	if (res < 0) {
269	kfree(n);
270	enic->rfs_h.free++;
271	goto ret_unlock;
272	}
273	n->rq_id = rxq_index;
274	n->fltr_id = res;
275	n->flow_id = flow_id;
276	n->keys = keys;
277	INIT_HLIST_NODE(&n->node);
278	hlist_add_head(&n->node, &enic->rfs_h.ht_head[tbl_idx]);
279	}
280
281	ret_unlock:
b6931c9b	282	spin_unlock_bh(&enic->rfs_h.lock);
a145df23 GV	283	return res;
	284	}
	285
a145df23	286	#endif /* CONFIG_RFS_ACCEL */