1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2020, Intel Corporation. */
3
4 #include "ice.h"
5 #include <net/rps.h>
6
7 /**
8 * ice_is_arfs_active - helper to check is aRFS is active
9 * @vsi: VSI to check
10 */
ice_is_arfs_active(struct ice_vsi * vsi)11 static bool ice_is_arfs_active(struct ice_vsi *vsi)
12 {
13 return !!vsi->arfs_fltr_list;
14 }
15
16 /**
17 * ice_is_arfs_using_perfect_flow - check if aRFS has active perfect filters
18 * @hw: pointer to the HW structure
19 * @flow_type: flow type as Flow Director understands it
20 *
21 * Flow Director will query this function to see if aRFS is currently using
22 * the specified flow_type for perfect (4-tuple) filters.
23 */
24 bool
ice_is_arfs_using_perfect_flow(struct ice_hw * hw,enum ice_fltr_ptype flow_type)25 ice_is_arfs_using_perfect_flow(struct ice_hw *hw, enum ice_fltr_ptype flow_type)
26 {
27 struct ice_arfs_active_fltr_cntrs *arfs_fltr_cntrs;
28 struct ice_pf *pf = hw->back;
29 struct ice_vsi *vsi;
30
31 vsi = ice_get_main_vsi(pf);
32 if (!vsi)
33 return false;
34
35 arfs_fltr_cntrs = vsi->arfs_fltr_cntrs;
36
37 /* active counters can be updated by multiple CPUs */
38 smp_mb__before_atomic();
39 switch (flow_type) {
40 case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
41 return atomic_read(&arfs_fltr_cntrs->active_udpv4_cnt) > 0;
42 case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
43 return atomic_read(&arfs_fltr_cntrs->active_udpv6_cnt) > 0;
44 case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
45 return atomic_read(&arfs_fltr_cntrs->active_tcpv4_cnt) > 0;
46 case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
47 return atomic_read(&arfs_fltr_cntrs->active_tcpv6_cnt) > 0;
48 default:
49 return false;
50 }
51 }
52
53 /**
54 * ice_arfs_update_active_fltr_cntrs - update active filter counters for aRFS
55 * @vsi: VSI that aRFS is active on
56 * @entry: aRFS entry used to change counters
57 * @add: true to increment counter, false to decrement
58 */
59 static void
ice_arfs_update_active_fltr_cntrs(struct ice_vsi * vsi,struct ice_arfs_entry * entry,bool add)60 ice_arfs_update_active_fltr_cntrs(struct ice_vsi *vsi,
61 struct ice_arfs_entry *entry, bool add)
62 {
63 struct ice_arfs_active_fltr_cntrs *fltr_cntrs = vsi->arfs_fltr_cntrs;
64
65 switch (entry->fltr_info.flow_type) {
66 case ICE_FLTR_PTYPE_NONF_IPV4_TCP:
67 if (add)
68 atomic_inc(&fltr_cntrs->active_tcpv4_cnt);
69 else
70 atomic_dec(&fltr_cntrs->active_tcpv4_cnt);
71 break;
72 case ICE_FLTR_PTYPE_NONF_IPV6_TCP:
73 if (add)
74 atomic_inc(&fltr_cntrs->active_tcpv6_cnt);
75 else
76 atomic_dec(&fltr_cntrs->active_tcpv6_cnt);
77 break;
78 case ICE_FLTR_PTYPE_NONF_IPV4_UDP:
79 if (add)
80 atomic_inc(&fltr_cntrs->active_udpv4_cnt);
81 else
82 atomic_dec(&fltr_cntrs->active_udpv4_cnt);
83 break;
84 case ICE_FLTR_PTYPE_NONF_IPV6_UDP:
85 if (add)
86 atomic_inc(&fltr_cntrs->active_udpv6_cnt);
87 else
88 atomic_dec(&fltr_cntrs->active_udpv6_cnt);
89 break;
90 default:
91 dev_err(ice_pf_to_dev(vsi->back), "aRFS: Failed to update filter counters, invalid filter type %d\n",
92 entry->fltr_info.flow_type);
93 }
94 }
95
96 /**
97 * ice_arfs_del_flow_rules - delete the rules passed in from HW
98 * @vsi: VSI for the flow rules that need to be deleted
99 * @del_list_head: head of the list of ice_arfs_entry(s) for rule deletion
100 *
101 * Loop through the delete list passed in and remove the rules from HW. After
102 * each rule is deleted, disconnect and free the ice_arfs_entry because it is no
103 * longer being referenced by the aRFS hash table.
104 */
105 static void
ice_arfs_del_flow_rules(struct ice_vsi * vsi,struct hlist_head * del_list_head)106 ice_arfs_del_flow_rules(struct ice_vsi *vsi, struct hlist_head *del_list_head)
107 {
108 struct ice_arfs_entry *e;
109 struct hlist_node *n;
110 struct device *dev;
111
112 dev = ice_pf_to_dev(vsi->back);
113
114 hlist_for_each_entry_safe(e, n, del_list_head, list_entry) {
115 int result;
116
117 result = ice_fdir_write_fltr(vsi->back, &e->fltr_info, false,
118 false);
119 if (!result)
120 ice_arfs_update_active_fltr_cntrs(vsi, e, false);
121 else
122 dev_dbg(dev, "Unable to delete aRFS entry, err %d fltr_state %d fltr_id %d flow_id %d Q %d\n",
123 result, e->fltr_state, e->fltr_info.fltr_id,
124 e->flow_id, e->fltr_info.q_index);
125
126 /* The aRFS hash table is no longer referencing this entry */
127 hlist_del(&e->list_entry);
128 devm_kfree(dev, e);
129 }
130 }
131
132 /**
133 * ice_arfs_add_flow_rules - add the rules passed in from HW
134 * @vsi: VSI for the flow rules that need to be added
135 * @add_list_head: head of the list of ice_arfs_entry_ptr(s) for rule addition
136 *
137 * Loop through the add list passed in and remove the rules from HW. After each
138 * rule is added, disconnect and free the ice_arfs_entry_ptr node. Don't free
139 * the ice_arfs_entry(s) because they are still being referenced in the aRFS
140 * hash table.
141 */
142 static void
ice_arfs_add_flow_rules(struct ice_vsi * vsi,struct hlist_head * add_list_head)143 ice_arfs_add_flow_rules(struct ice_vsi *vsi, struct hlist_head *add_list_head)
144 {
145 struct ice_arfs_entry_ptr *ep;
146 struct hlist_node *n;
147 struct device *dev;
148
149 dev = ice_pf_to_dev(vsi->back);
150
151 hlist_for_each_entry_safe(ep, n, add_list_head, list_entry) {
152 int result;
153
154 result = ice_fdir_write_fltr(vsi->back,
155 &ep->arfs_entry->fltr_info, true,
156 false);
157 if (!result)
158 ice_arfs_update_active_fltr_cntrs(vsi, ep->arfs_entry,
159 true);
160 else
161 dev_dbg(dev, "Unable to add aRFS entry, err %d fltr_state %d fltr_id %d flow_id %d Q %d\n",
162 result, ep->arfs_entry->fltr_state,
163 ep->arfs_entry->fltr_info.fltr_id,
164 ep->arfs_entry->flow_id,
165 ep->arfs_entry->fltr_info.q_index);
166
167 hlist_del(&ep->list_entry);
168 devm_kfree(dev, ep);
169 }
170 }
171
172 /**
173 * ice_arfs_is_flow_expired - check if the aRFS entry has expired
174 * @vsi: VSI containing the aRFS entry
175 * @arfs_entry: aRFS entry that's being checked for expiration
176 *
177 * Return true if the flow has expired, else false. This function should be used
178 * to determine whether or not an aRFS entry should be removed from the hardware
179 * and software structures.
180 */
181 static bool
ice_arfs_is_flow_expired(struct ice_vsi * vsi,struct ice_arfs_entry * arfs_entry)182 ice_arfs_is_flow_expired(struct ice_vsi *vsi, struct ice_arfs_entry *arfs_entry)
183 {
184 #define ICE_ARFS_TIME_DELTA_EXPIRATION msecs_to_jiffies(5000)
185 if (rps_may_expire_flow(vsi->netdev, arfs_entry->fltr_info.q_index,
186 arfs_entry->flow_id,
187 arfs_entry->fltr_info.fltr_id))
188 return true;
189
190 /* expiration timer only used for UDP filters */
191 if (arfs_entry->fltr_info.flow_type != ICE_FLTR_PTYPE_NONF_IPV4_UDP &&
192 arfs_entry->fltr_info.flow_type != ICE_FLTR_PTYPE_NONF_IPV6_UDP)
193 return false;
194
195 return time_in_range64(arfs_entry->time_activated +
196 ICE_ARFS_TIME_DELTA_EXPIRATION,
197 arfs_entry->time_activated, get_jiffies_64());
198 }
199
200 /**
201 * ice_arfs_update_flow_rules - add/delete aRFS rules in HW
202 * @vsi: the VSI to be forwarded to
203 * @idx: index into the table of aRFS filter lists. Obtained from skb->hash
204 * @add_list: list to populate with filters to be added to Flow Director
205 * @del_list: list to populate with filters to be deleted from Flow Director
206 *
207 * Iterate over the hlist at the index given in the aRFS hash table and
208 * determine if there are any aRFS entries that need to be either added or
209 * deleted in the HW. If the aRFS entry is marked as ICE_ARFS_INACTIVE the
210 * filter needs to be added to HW, else if it's marked as ICE_ARFS_ACTIVE and
211 * the flow has expired delete the filter from HW. The caller of this function
212 * is expected to add/delete rules on the add_list/del_list respectively.
213 */
214 static void
ice_arfs_update_flow_rules(struct ice_vsi * vsi,u16 idx,struct hlist_head * add_list,struct hlist_head * del_list)215 ice_arfs_update_flow_rules(struct ice_vsi *vsi, u16 idx,
216 struct hlist_head *add_list,
217 struct hlist_head *del_list)
218 {
219 struct ice_arfs_entry *e;
220 struct hlist_node *n;
221 struct device *dev;
222
223 dev = ice_pf_to_dev(vsi->back);
224
225 /* go through the aRFS hlist at this idx and check for needed updates */
226 hlist_for_each_entry_safe(e, n, &vsi->arfs_fltr_list[idx], list_entry)
227 /* check if filter needs to be added to HW */
228 if (e->fltr_state == ICE_ARFS_INACTIVE) {
229 enum ice_fltr_ptype flow_type = e->fltr_info.flow_type;
230 struct ice_arfs_entry_ptr *ep =
231 devm_kzalloc(dev, sizeof(*ep), GFP_ATOMIC);
232
233 if (!ep)
234 continue;
235 INIT_HLIST_NODE(&ep->list_entry);
236 /* reference aRFS entry to add HW filter */
237 ep->arfs_entry = e;
238 hlist_add_head(&ep->list_entry, add_list);
239 e->fltr_state = ICE_ARFS_ACTIVE;
240 /* expiration timer only used for UDP flows */
241 if (flow_type == ICE_FLTR_PTYPE_NONF_IPV4_UDP ||
242 flow_type == ICE_FLTR_PTYPE_NONF_IPV6_UDP)
243 e->time_activated = get_jiffies_64();
244 } else if (e->fltr_state == ICE_ARFS_ACTIVE) {
245 /* check if filter needs to be removed from HW */
246 if (ice_arfs_is_flow_expired(vsi, e)) {
247 /* remove aRFS entry from hash table for delete
248 * and to prevent referencing it the next time
249 * through this hlist index
250 */
251 hlist_del(&e->list_entry);
252 e->fltr_state = ICE_ARFS_TODEL;
253 /* save reference to aRFS entry for delete */
254 hlist_add_head(&e->list_entry, del_list);
255 }
256 }
257 }
258
259 /**
260 * ice_sync_arfs_fltrs - update all aRFS filters
261 * @pf: board private structure
262 */
ice_sync_arfs_fltrs(struct ice_pf * pf)263 void ice_sync_arfs_fltrs(struct ice_pf *pf)
264 {
265 HLIST_HEAD(tmp_del_list);
266 HLIST_HEAD(tmp_add_list);
267 struct ice_vsi *pf_vsi;
268 unsigned int i;
269
270 pf_vsi = ice_get_main_vsi(pf);
271 if (!pf_vsi)
272 return;
273
274 if (!ice_is_arfs_active(pf_vsi))
275 return;
276
277 spin_lock_bh(&pf_vsi->arfs_lock);
278 /* Once we process aRFS for the PF VSI get out */
279 for (i = 0; i < ICE_MAX_ARFS_LIST; i++)
280 ice_arfs_update_flow_rules(pf_vsi, i, &tmp_add_list,
281 &tmp_del_list);
282 spin_unlock_bh(&pf_vsi->arfs_lock);
283
284 /* use list of ice_arfs_entry(s) for delete */
285 ice_arfs_del_flow_rules(pf_vsi, &tmp_del_list);
286
287 /* use list of ice_arfs_entry_ptr(s) for add */
288 ice_arfs_add_flow_rules(pf_vsi, &tmp_add_list);
289 }
290
291 /**
292 * ice_arfs_build_entry - builds an aRFS entry based on input
293 * @vsi: destination VSI for this flow
294 * @fk: flow dissector keys for creating the tuple
295 * @rxq_idx: Rx queue to steer this flow to
296 * @flow_id: passed down from the stack and saved for flow expiration
297 *
298 * returns an aRFS entry on success and NULL on failure
299 */
300 static struct ice_arfs_entry *
ice_arfs_build_entry(struct ice_vsi * vsi,const struct flow_keys * fk,u16 rxq_idx,u32 flow_id)301 ice_arfs_build_entry(struct ice_vsi *vsi, const struct flow_keys *fk,
302 u16 rxq_idx, u32 flow_id)
303 {
304 struct ice_arfs_entry *arfs_entry;
305 struct ice_fdir_fltr *fltr_info;
306 u8 ip_proto;
307
308 arfs_entry = devm_kzalloc(ice_pf_to_dev(vsi->back),
309 sizeof(*arfs_entry),
310 GFP_ATOMIC | __GFP_NOWARN);
311 if (!arfs_entry)
312 return NULL;
313
314 fltr_info = &arfs_entry->fltr_info;
315 fltr_info->q_index = rxq_idx;
316 fltr_info->dest_ctl = ICE_FLTR_PRGM_DESC_DEST_DIRECT_PKT_QINDEX;
317 fltr_info->dest_vsi = vsi->idx;
318 ip_proto = fk->basic.ip_proto;
319
320 if (fk->basic.n_proto == htons(ETH_P_IP)) {
321 fltr_info->ip.v4.proto = ip_proto;
322 fltr_info->flow_type = (ip_proto == IPPROTO_TCP) ?
323 ICE_FLTR_PTYPE_NONF_IPV4_TCP :
324 ICE_FLTR_PTYPE_NONF_IPV4_UDP;
325 fltr_info->ip.v4.src_ip = fk->addrs.v4addrs.src;
326 fltr_info->ip.v4.dst_ip = fk->addrs.v4addrs.dst;
327 fltr_info->ip.v4.src_port = fk->ports.src;
328 fltr_info->ip.v4.dst_port = fk->ports.dst;
329 } else { /* ETH_P_IPV6 */
330 fltr_info->ip.v6.proto = ip_proto;
331 fltr_info->flow_type = (ip_proto == IPPROTO_TCP) ?
332 ICE_FLTR_PTYPE_NONF_IPV6_TCP :
333 ICE_FLTR_PTYPE_NONF_IPV6_UDP;
334 memcpy(&fltr_info->ip.v6.src_ip, &fk->addrs.v6addrs.src,
335 sizeof(struct in6_addr));
336 memcpy(&fltr_info->ip.v6.dst_ip, &fk->addrs.v6addrs.dst,
337 sizeof(struct in6_addr));
338 fltr_info->ip.v6.src_port = fk->ports.src;
339 fltr_info->ip.v6.dst_port = fk->ports.dst;
340 }
341
342 arfs_entry->flow_id = flow_id;
343 fltr_info->fltr_id =
344 atomic_inc_return(vsi->arfs_last_fltr_id) % RPS_NO_FILTER;
345
346 return arfs_entry;
347 }
348
349 /**
350 * ice_arfs_is_perfect_flow_set - Check to see if perfect flow is set
351 * @hw: pointer to HW structure
352 * @l3_proto: ETH_P_IP or ETH_P_IPV6 in network order
353 * @l4_proto: IPPROTO_UDP or IPPROTO_TCP
354 *
355 * We only support perfect (4-tuple) filters for aRFS. This function allows aRFS
356 * to check if perfect (4-tuple) flow rules are currently in place by Flow
357 * Director.
358 */
359 static bool
ice_arfs_is_perfect_flow_set(struct ice_hw * hw,__be16 l3_proto,u8 l4_proto)360 ice_arfs_is_perfect_flow_set(struct ice_hw *hw, __be16 l3_proto, u8 l4_proto)
361 {
362 unsigned long *perfect_fltr = hw->fdir_perfect_fltr;
363
364 /* advanced Flow Director disabled, perfect filters always supported */
365 if (!perfect_fltr)
366 return true;
367
368 if (l3_proto == htons(ETH_P_IP) && l4_proto == IPPROTO_UDP)
369 return test_bit(ICE_FLTR_PTYPE_NONF_IPV4_UDP, perfect_fltr);
370 else if (l3_proto == htons(ETH_P_IP) && l4_proto == IPPROTO_TCP)
371 return test_bit(ICE_FLTR_PTYPE_NONF_IPV4_TCP, perfect_fltr);
372 else if (l3_proto == htons(ETH_P_IPV6) && l4_proto == IPPROTO_UDP)
373 return test_bit(ICE_FLTR_PTYPE_NONF_IPV6_UDP, perfect_fltr);
374 else if (l3_proto == htons(ETH_P_IPV6) && l4_proto == IPPROTO_TCP)
375 return test_bit(ICE_FLTR_PTYPE_NONF_IPV6_TCP, perfect_fltr);
376
377 return false;
378 }
379
380 /**
381 * ice_rx_flow_steer - steer the Rx flow to where application is being run
382 * @netdev: ptr to the netdev being adjusted
383 * @skb: buffer with required header information
384 * @rxq_idx: queue to which the flow needs to move
385 * @flow_id: flow identifier provided by the netdev
386 *
387 * Based on the skb, rxq_idx, and flow_id passed in add/update an entry in the
388 * aRFS hash table. Iterate over one of the hlists in the aRFS hash table and
389 * if the flow_id already exists in the hash table but the rxq_idx has changed
390 * mark the entry as ICE_ARFS_INACTIVE so it can get updated in HW, else
391 * if the entry is marked as ICE_ARFS_TODEL delete it from the aRFS hash table.
392 * If neither of the previous conditions are true then add a new entry in the
393 * aRFS hash table, which gets set to ICE_ARFS_INACTIVE by default so it can be
394 * added to HW.
395 */
396 int
ice_rx_flow_steer(struct net_device * netdev,const struct sk_buff * skb,u16 rxq_idx,u32 flow_id)397 ice_rx_flow_steer(struct net_device *netdev, const struct sk_buff *skb,
398 u16 rxq_idx, u32 flow_id)
399 {
400 struct ice_netdev_priv *np = netdev_priv(netdev);
401 struct ice_arfs_entry *arfs_entry;
402 struct ice_vsi *vsi = np->vsi;
403 struct flow_keys fk;
404 struct ice_pf *pf;
405 __be16 n_proto;
406 u8 ip_proto;
407 u16 idx;
408 int ret;
409
410 /* failed to allocate memory for aRFS so don't crash */
411 if (unlikely(!vsi->arfs_fltr_list))
412 return -ENODEV;
413
414 pf = vsi->back;
415
416 if (skb->encapsulation)
417 return -EPROTONOSUPPORT;
418
419 if (!skb_flow_dissect_flow_keys(skb, &fk, 0))
420 return -EPROTONOSUPPORT;
421
422 n_proto = fk.basic.n_proto;
423 /* Support only IPV4 and IPV6 */
424 if ((n_proto == htons(ETH_P_IP) && !ip_is_fragment(ip_hdr(skb))) ||
425 n_proto == htons(ETH_P_IPV6))
426 ip_proto = fk.basic.ip_proto;
427 else
428 return -EPROTONOSUPPORT;
429
430 /* Support only TCP and UDP */
431 if (ip_proto != IPPROTO_TCP && ip_proto != IPPROTO_UDP)
432 return -EPROTONOSUPPORT;
433
434 /* only support 4-tuple filters for aRFS */
435 if (!ice_arfs_is_perfect_flow_set(&pf->hw, n_proto, ip_proto))
436 return -EOPNOTSUPP;
437
438 /* choose the aRFS list bucket based on skb hash */
439 idx = skb_get_hash_raw(skb) & ICE_ARFS_LST_MASK;
440 /* search for entry in the bucket */
441 spin_lock_bh(&vsi->arfs_lock);
442 hlist_for_each_entry(arfs_entry, &vsi->arfs_fltr_list[idx],
443 list_entry) {
444 struct ice_fdir_fltr *fltr_info;
445
446 /* keep searching for the already existing arfs_entry flow */
447 if (arfs_entry->flow_id != flow_id)
448 continue;
449
450 fltr_info = &arfs_entry->fltr_info;
451 ret = fltr_info->fltr_id;
452
453 if (fltr_info->q_index == rxq_idx ||
454 arfs_entry->fltr_state != ICE_ARFS_ACTIVE)
455 goto out;
456
457 /* update the queue to forward to on an already existing flow */
458 fltr_info->q_index = rxq_idx;
459 arfs_entry->fltr_state = ICE_ARFS_INACTIVE;
460 ice_arfs_update_active_fltr_cntrs(vsi, arfs_entry, false);
461 goto out_schedule_service_task;
462 }
463
464 arfs_entry = ice_arfs_build_entry(vsi, &fk, rxq_idx, flow_id);
465 if (!arfs_entry) {
466 ret = -ENOMEM;
467 goto out;
468 }
469
470 ret = arfs_entry->fltr_info.fltr_id;
471 INIT_HLIST_NODE(&arfs_entry->list_entry);
472 hlist_add_head(&arfs_entry->list_entry, &vsi->arfs_fltr_list[idx]);
473 out_schedule_service_task:
474 ice_service_task_schedule(pf);
475 out:
476 spin_unlock_bh(&vsi->arfs_lock);
477 return ret;
478 }
479
480 /**
481 * ice_init_arfs_cntrs - initialize aRFS counter values
482 * @vsi: VSI that aRFS counters need to be initialized on
483 */
ice_init_arfs_cntrs(struct ice_vsi * vsi)484 static int ice_init_arfs_cntrs(struct ice_vsi *vsi)
485 {
486 if (!vsi || vsi->type != ICE_VSI_PF)
487 return -EINVAL;
488
489 vsi->arfs_fltr_cntrs = kzalloc(sizeof(*vsi->arfs_fltr_cntrs),
490 GFP_KERNEL);
491 if (!vsi->arfs_fltr_cntrs)
492 return -ENOMEM;
493
494 vsi->arfs_last_fltr_id = kzalloc(sizeof(*vsi->arfs_last_fltr_id),
495 GFP_KERNEL);
496 if (!vsi->arfs_last_fltr_id) {
497 kfree(vsi->arfs_fltr_cntrs);
498 vsi->arfs_fltr_cntrs = NULL;
499 return -ENOMEM;
500 }
501
502 return 0;
503 }
504
505 /**
506 * ice_init_arfs - initialize aRFS resources
507 * @vsi: the VSI to be forwarded to
508 */
ice_init_arfs(struct ice_vsi * vsi)509 void ice_init_arfs(struct ice_vsi *vsi)
510 {
511 struct hlist_head *arfs_fltr_list;
512 unsigned int i;
513
514 if (!vsi || vsi->type != ICE_VSI_PF || ice_is_arfs_active(vsi))
515 return;
516
517 arfs_fltr_list = kcalloc(ICE_MAX_ARFS_LIST, sizeof(*arfs_fltr_list),
518 GFP_KERNEL);
519 if (!arfs_fltr_list)
520 return;
521
522 if (ice_init_arfs_cntrs(vsi))
523 goto free_arfs_fltr_list;
524
525 for (i = 0; i < ICE_MAX_ARFS_LIST; i++)
526 INIT_HLIST_HEAD(&arfs_fltr_list[i]);
527
528 spin_lock_init(&vsi->arfs_lock);
529
530 vsi->arfs_fltr_list = arfs_fltr_list;
531
532 return;
533
534 free_arfs_fltr_list:
535 kfree(arfs_fltr_list);
536 }
537
538 /**
539 * ice_clear_arfs - clear the aRFS hash table and any memory used for aRFS
540 * @vsi: the VSI to be forwarded to
541 */
ice_clear_arfs(struct ice_vsi * vsi)542 void ice_clear_arfs(struct ice_vsi *vsi)
543 {
544 struct device *dev;
545 unsigned int i;
546
547 if (!vsi || vsi->type != ICE_VSI_PF || !vsi->back ||
548 !vsi->arfs_fltr_list)
549 return;
550
551 dev = ice_pf_to_dev(vsi->back);
552 for (i = 0; i < ICE_MAX_ARFS_LIST; i++) {
553 struct ice_arfs_entry *r;
554 struct hlist_node *n;
555
556 spin_lock_bh(&vsi->arfs_lock);
557 hlist_for_each_entry_safe(r, n, &vsi->arfs_fltr_list[i],
558 list_entry) {
559 hlist_del(&r->list_entry);
560 devm_kfree(dev, r);
561 }
562 spin_unlock_bh(&vsi->arfs_lock);
563 }
564
565 kfree(vsi->arfs_fltr_list);
566 vsi->arfs_fltr_list = NULL;
567 kfree(vsi->arfs_last_fltr_id);
568 vsi->arfs_last_fltr_id = NULL;
569 kfree(vsi->arfs_fltr_cntrs);
570 vsi->arfs_fltr_cntrs = NULL;
571 }
572
573 /**
574 * ice_free_cpu_rx_rmap - free setup CPU reverse map
575 * @vsi: the VSI to be forwarded to
576 */
ice_free_cpu_rx_rmap(struct ice_vsi * vsi)577 void ice_free_cpu_rx_rmap(struct ice_vsi *vsi)
578 {
579 struct net_device *netdev;
580
581 if (!vsi || vsi->type != ICE_VSI_PF)
582 return;
583
584 netdev = vsi->netdev;
585 if (!netdev || !netdev->rx_cpu_rmap)
586 return;
587
588 free_irq_cpu_rmap(netdev->rx_cpu_rmap);
589 netdev->rx_cpu_rmap = NULL;
590 }
591
592 /**
593 * ice_set_cpu_rx_rmap - setup CPU reverse map for each queue
594 * @vsi: the VSI to be forwarded to
595 */
ice_set_cpu_rx_rmap(struct ice_vsi * vsi)596 int ice_set_cpu_rx_rmap(struct ice_vsi *vsi)
597 {
598 struct net_device *netdev;
599 struct ice_pf *pf;
600 int i;
601
602 if (!vsi || vsi->type != ICE_VSI_PF)
603 return 0;
604
605 pf = vsi->back;
606 netdev = vsi->netdev;
607 if (!pf || !netdev || !vsi->num_q_vectors)
608 return -EINVAL;
609
610 netdev_dbg(netdev, "Setup CPU RMAP: vsi type 0x%x, ifname %s, q_vectors %d\n",
611 vsi->type, netdev->name, vsi->num_q_vectors);
612
613 netdev->rx_cpu_rmap = alloc_irq_cpu_rmap(vsi->num_q_vectors);
614 if (unlikely(!netdev->rx_cpu_rmap))
615 return -EINVAL;
616
617 ice_for_each_q_vector(vsi, i)
618 if (irq_cpu_rmap_add(netdev->rx_cpu_rmap,
619 vsi->q_vectors[i]->irq.virq)) {
620 ice_free_cpu_rx_rmap(vsi);
621 return -EINVAL;
622 }
623
624 return 0;
625 }
626
627 /**
628 * ice_remove_arfs - remove/clear all aRFS resources
629 * @pf: device private structure
630 */
ice_remove_arfs(struct ice_pf * pf)631 void ice_remove_arfs(struct ice_pf *pf)
632 {
633 struct ice_vsi *pf_vsi;
634
635 pf_vsi = ice_get_main_vsi(pf);
636 if (!pf_vsi)
637 return;
638
639 ice_clear_arfs(pf_vsi);
640 }
641
642 /**
643 * ice_rebuild_arfs - remove/clear all aRFS resources and rebuild after reset
644 * @pf: device private structure
645 */
ice_rebuild_arfs(struct ice_pf * pf)646 void ice_rebuild_arfs(struct ice_pf *pf)
647 {
648 struct ice_vsi *pf_vsi;
649
650 pf_vsi = ice_get_main_vsi(pf);
651 if (!pf_vsi)
652 return;
653
654 ice_remove_arfs(pf);
655 ice_init_arfs(pf_vsi);
656 }
657