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