1 // SPDX-License-Identifier: GPL-2.0
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>
9 #include <net/flow_dissector.h>
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
19  * added. In case of error it returns a negative number.
20  */
21 int enic_addfltr_5t(struct enic *enic, struct flow_keys *keys, u16 rq)
22 {
23 	int res;
24 	struct filter data;
25 
26 	switch (keys->basic.ip_proto) {
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 
37 	data.type = FILTER_IPV4_5TUPLE;
38 	data.u.ipv4.src_addr = ntohl(keys->addrs.v4addrs.src);
39 	data.u.ipv4.dst_addr = ntohl(keys->addrs.v4addrs.dst);
40 	data.u.ipv4.src_port = ntohs(keys->ports.src);
41 	data.u.ipv4.dst_port = ntohs(keys->ports.dst);
42 	data.u.ipv4.flags = FILTER_FIELDS_IPV4_5TUPLE;
43 
44 	spin_lock_bh(&enic->devcmd_lock);
45 	res = vnic_dev_classifier(enic->vdev, CLSF_ADD, &rq, &data);
46 	spin_unlock_bh(&enic->devcmd_lock);
47 	res = (res == 0) ? rq : res;
48 
49 	return res;
50 }
51 
52 /* enic_delfltr - Delete clsf filter
53  *	@enic: enic struct of vnic
54  *	@filter_id: filter_is(hardware_id) of filter to be deleted
55  *
56  * This function returns zero in case of success, negative number incase of
57  * error.
58  */
59 int enic_delfltr(struct enic *enic, u16 filter_id)
60 {
61 	int ret;
62 
63 	spin_lock_bh(&enic->devcmd_lock);
64 	ret = vnic_dev_classifier(enic->vdev, CLSF_DEL, &filter_id, NULL);
65 	spin_unlock_bh(&enic->devcmd_lock);
66 
67 	return ret;
68 }
69 
70 /* enic_rfs_flw_tbl_init - initialize enic->rfs_h members
71  *	@enic: enic data
72  */
73 void enic_rfs_flw_tbl_init(struct enic *enic)
74 {
75 	int i;
76 
77 	spin_lock_init(&enic->rfs_h.lock);
78 	for (i = 0; i <= ENIC_RFS_FLW_MASK; i++)
79 		INIT_HLIST_HEAD(&enic->rfs_h.ht_head[i]);
80 	enic->rfs_h.max = enic->config.num_arfs;
81 	enic->rfs_h.free = enic->rfs_h.max;
82 	enic->rfs_h.toclean = 0;
83 }
84 
85 void enic_rfs_flw_tbl_free(struct enic *enic)
86 {
87 	int i;
88 
89 	enic_rfs_timer_stop(enic);
90 	spin_lock_bh(&enic->rfs_h.lock);
91 	for (i = 0; i < (1 << ENIC_RFS_FLW_BITSHIFT); i++) {
92 		struct hlist_head *hhead;
93 		struct hlist_node *tmp;
94 		struct enic_rfs_fltr_node *n;
95 
96 		hhead = &enic->rfs_h.ht_head[i];
97 		hlist_for_each_entry_safe(n, tmp, hhead, node) {
98 			enic_delfltr(enic, n->fltr_id);
99 			hlist_del(&n->node);
100 			kfree(n);
101 			enic->rfs_h.free++;
102 		}
103 	}
104 	spin_unlock_bh(&enic->rfs_h.lock);
105 }
106 
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 
125 #ifdef CONFIG_RFS_ACCEL
126 void enic_flow_may_expire(struct timer_list *t)
127 {
128 	struct enic *enic = from_timer(enic, t, rfs_h.rfs_may_expire);
129 	bool res;
130 	int j;
131 
132 	spin_lock_bh(&enic->rfs_h.lock);
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 	}
152 	spin_unlock_bh(&enic->rfs_h.lock);
153 	mod_timer(&enic->rfs_h.rfs_may_expire, jiffies + HZ/4);
154 }
155 
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)
162 		if (tpos->keys.addrs.v4addrs.src == k->addrs.v4addrs.src &&
163 		    tpos->keys.addrs.v4addrs.dst == k->addrs.v4addrs.dst &&
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)
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);
181 	res = skb_flow_dissect_flow_keys(skb, &keys, 0);
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))
185 		return -EPROTONOSUPPORT;
186 
187 	tbl_idx = skb_get_hash_raw(skb) & ENIC_RFS_FLW_MASK;
188 	spin_lock_bh(&enic->rfs_h.lock);
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:
282 	spin_unlock_bh(&enic->rfs_h.lock);
283 	return res;
284 }
285 
286 #endif /* CONFIG_RFS_ACCEL */
287