1 /* 2 * Copyright(c) 2017 Intel Corporation. 3 * 4 * This file is provided under a dual BSD/GPLv2 license. When using or 5 * redistributing this file, you may do so under either license. 6 * 7 * GPL LICENSE SUMMARY 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * BSD LICENSE 19 * 20 * Redistribution and use in source and binary forms, with or without 21 * modification, are permitted provided that the following conditions 22 * are met: 23 * 24 * - Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * - Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in 28 * the documentation and/or other materials provided with the 29 * distribution. 30 * - Neither the name of Intel Corporation nor the names of its 31 * contributors may be used to endorse or promote products derived 32 * from this software without specific prior written permission. 33 * 34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 45 * 46 */ 47 48 /* 49 * This file contains OPA VNIC encapsulation/decapsulation function. 50 */ 51 52 #include <linux/if_ether.h> 53 #include <linux/if_vlan.h> 54 55 #include "opa_vnic_internal.h" 56 57 /* OPA 16B Header fields */ 58 #define OPA_16B_LID_MASK 0xFFFFFull 59 #define OPA_16B_SLID_HIGH_SHFT 8 60 #define OPA_16B_SLID_MASK 0xF00ull 61 #define OPA_16B_DLID_MASK 0xF000ull 62 #define OPA_16B_DLID_HIGH_SHFT 12 63 #define OPA_16B_LEN_SHFT 20 64 #define OPA_16B_SC_SHFT 20 65 #define OPA_16B_RC_SHFT 25 66 #define OPA_16B_PKEY_SHFT 16 67 68 #define OPA_VNIC_L4_HDR_SHFT 16 69 70 /* L2+L4 hdr len is 20 bytes (5 quad words) */ 71 #define OPA_VNIC_HDR_QW_LEN 5 72 73 static inline void opa_vnic_make_header(u8 *hdr, u32 slid, u32 dlid, u16 len, 74 u16 pkey, u16 entropy, u8 sc, u8 rc, 75 u8 l4_type, u16 l4_hdr) 76 { 77 /* h[1]: LT=1, 16B L2=10 */ 78 u32 h[OPA_VNIC_HDR_QW_LEN] = {0, 0xc0000000, 0, 0, 0}; 79 80 h[2] = l4_type; 81 h[3] = entropy; 82 h[4] = l4_hdr << OPA_VNIC_L4_HDR_SHFT; 83 84 /* Extract and set 4 upper bits and 20 lower bits of the lids */ 85 h[0] |= (slid & OPA_16B_LID_MASK); 86 h[2] |= ((slid >> (20 - OPA_16B_SLID_HIGH_SHFT)) & OPA_16B_SLID_MASK); 87 88 h[1] |= (dlid & OPA_16B_LID_MASK); 89 h[2] |= ((dlid >> (20 - OPA_16B_DLID_HIGH_SHFT)) & OPA_16B_DLID_MASK); 90 91 h[0] |= (len << OPA_16B_LEN_SHFT); 92 h[1] |= (rc << OPA_16B_RC_SHFT); 93 h[1] |= (sc << OPA_16B_SC_SHFT); 94 h[2] |= ((u32)pkey << OPA_16B_PKEY_SHFT); 95 96 memcpy(hdr, h, OPA_VNIC_HDR_LEN); 97 } 98 99 /* 100 * Using a simple hash table for mac table implementation with the last octet 101 * of mac address as a key. 102 */ 103 static void opa_vnic_free_mac_tbl(struct hlist_head *mactbl) 104 { 105 struct opa_vnic_mac_tbl_node *node; 106 struct hlist_node *tmp; 107 int bkt; 108 109 if (!mactbl) 110 return; 111 112 vnic_hash_for_each_safe(mactbl, bkt, tmp, node, hlist) { 113 hash_del(&node->hlist); 114 kfree(node); 115 } 116 kfree(mactbl); 117 } 118 119 static struct hlist_head *opa_vnic_alloc_mac_tbl(void) 120 { 121 u32 size = sizeof(struct hlist_head) * OPA_VNIC_MAC_TBL_SIZE; 122 struct hlist_head *mactbl; 123 124 mactbl = kzalloc(size, GFP_KERNEL); 125 if (!mactbl) 126 return ERR_PTR(-ENOMEM); 127 128 vnic_hash_init(mactbl); 129 return mactbl; 130 } 131 132 /* opa_vnic_release_mac_tbl - empty and free the mac table */ 133 void opa_vnic_release_mac_tbl(struct opa_vnic_adapter *adapter) 134 { 135 struct hlist_head *mactbl; 136 137 mutex_lock(&adapter->mactbl_lock); 138 mactbl = rcu_access_pointer(adapter->mactbl); 139 rcu_assign_pointer(adapter->mactbl, NULL); 140 synchronize_rcu(); 141 opa_vnic_free_mac_tbl(mactbl); 142 adapter->info.vport.mac_tbl_digest = 0; 143 mutex_unlock(&adapter->mactbl_lock); 144 } 145 146 /* 147 * opa_vnic_query_mac_tbl - query the mac table for a section 148 * 149 * This function implements query of specific function of the mac table. 150 * The function also expects the requested range to be valid. 151 */ 152 void opa_vnic_query_mac_tbl(struct opa_vnic_adapter *adapter, 153 struct opa_veswport_mactable *tbl) 154 { 155 struct opa_vnic_mac_tbl_node *node; 156 struct hlist_head *mactbl; 157 int bkt; 158 u16 loffset, lnum_entries; 159 160 rcu_read_lock(); 161 mactbl = rcu_dereference(adapter->mactbl); 162 if (!mactbl) 163 goto get_mac_done; 164 165 loffset = be16_to_cpu(tbl->offset); 166 lnum_entries = be16_to_cpu(tbl->num_entries); 167 168 vnic_hash_for_each(mactbl, bkt, node, hlist) { 169 struct __opa_vnic_mactable_entry *nentry = &node->entry; 170 struct opa_veswport_mactable_entry *entry; 171 172 if ((node->index < loffset) || 173 (node->index >= (loffset + lnum_entries))) 174 continue; 175 176 /* populate entry in the tbl corresponding to the index */ 177 entry = &tbl->tbl_entries[node->index - loffset]; 178 memcpy(entry->mac_addr, nentry->mac_addr, 179 ARRAY_SIZE(entry->mac_addr)); 180 memcpy(entry->mac_addr_mask, nentry->mac_addr_mask, 181 ARRAY_SIZE(entry->mac_addr_mask)); 182 entry->dlid_sd = cpu_to_be32(nentry->dlid_sd); 183 } 184 tbl->mac_tbl_digest = cpu_to_be32(adapter->info.vport.mac_tbl_digest); 185 get_mac_done: 186 rcu_read_unlock(); 187 } 188 189 /* 190 * opa_vnic_update_mac_tbl - update mac table section 191 * 192 * This function updates the specified section of the mac table. 193 * The procedure includes following steps. 194 * - Allocate a new mac (hash) table. 195 * - Add the specified entries to the new table. 196 * (except the ones that are requested to be deleted). 197 * - Add all the other entries from the old mac table. 198 * - If there is a failure, free the new table and return. 199 * - Switch to the new table. 200 * - Free the old table and return. 201 * 202 * The function also expects the requested range to be valid. 203 */ 204 int opa_vnic_update_mac_tbl(struct opa_vnic_adapter *adapter, 205 struct opa_veswport_mactable *tbl) 206 { 207 struct opa_vnic_mac_tbl_node *node, *new_node; 208 struct hlist_head *new_mactbl, *old_mactbl; 209 int i, bkt, rc = 0; 210 u8 key; 211 u16 loffset, lnum_entries; 212 213 mutex_lock(&adapter->mactbl_lock); 214 /* allocate new mac table */ 215 new_mactbl = opa_vnic_alloc_mac_tbl(); 216 if (IS_ERR(new_mactbl)) { 217 mutex_unlock(&adapter->mactbl_lock); 218 return PTR_ERR(new_mactbl); 219 } 220 221 loffset = be16_to_cpu(tbl->offset); 222 lnum_entries = be16_to_cpu(tbl->num_entries); 223 224 /* add updated entries to the new mac table */ 225 for (i = 0; i < lnum_entries; i++) { 226 struct __opa_vnic_mactable_entry *nentry; 227 struct opa_veswport_mactable_entry *entry = 228 &tbl->tbl_entries[i]; 229 u8 *mac_addr = entry->mac_addr; 230 u8 empty_mac[ETH_ALEN] = { 0 }; 231 232 v_dbg("new mac entry %4d: %02x:%02x:%02x:%02x:%02x:%02x %x\n", 233 loffset + i, mac_addr[0], mac_addr[1], mac_addr[2], 234 mac_addr[3], mac_addr[4], mac_addr[5], 235 entry->dlid_sd); 236 237 /* if the entry is being removed, do not add it */ 238 if (!memcmp(mac_addr, empty_mac, ARRAY_SIZE(empty_mac))) 239 continue; 240 241 node = kzalloc(sizeof(*node), GFP_KERNEL); 242 if (!node) { 243 rc = -ENOMEM; 244 goto updt_done; 245 } 246 247 node->index = loffset + i; 248 nentry = &node->entry; 249 memcpy(nentry->mac_addr, entry->mac_addr, 250 ARRAY_SIZE(nentry->mac_addr)); 251 memcpy(nentry->mac_addr_mask, entry->mac_addr_mask, 252 ARRAY_SIZE(nentry->mac_addr_mask)); 253 nentry->dlid_sd = be32_to_cpu(entry->dlid_sd); 254 key = node->entry.mac_addr[OPA_VNIC_MAC_HASH_IDX]; 255 vnic_hash_add(new_mactbl, &node->hlist, key); 256 } 257 258 /* add other entries from current mac table to new mac table */ 259 old_mactbl = rcu_access_pointer(adapter->mactbl); 260 if (!old_mactbl) 261 goto switch_tbl; 262 263 vnic_hash_for_each(old_mactbl, bkt, node, hlist) { 264 if ((node->index >= loffset) && 265 (node->index < (loffset + lnum_entries))) 266 continue; 267 268 new_node = kzalloc(sizeof(*new_node), GFP_KERNEL); 269 if (!new_node) { 270 rc = -ENOMEM; 271 goto updt_done; 272 } 273 274 new_node->index = node->index; 275 memcpy(&new_node->entry, &node->entry, sizeof(node->entry)); 276 key = new_node->entry.mac_addr[OPA_VNIC_MAC_HASH_IDX]; 277 vnic_hash_add(new_mactbl, &new_node->hlist, key); 278 } 279 280 switch_tbl: 281 /* switch to new table */ 282 rcu_assign_pointer(adapter->mactbl, new_mactbl); 283 synchronize_rcu(); 284 285 adapter->info.vport.mac_tbl_digest = be32_to_cpu(tbl->mac_tbl_digest); 286 updt_done: 287 /* upon failure, free the new table; otherwise, free the old table */ 288 if (rc) 289 opa_vnic_free_mac_tbl(new_mactbl); 290 else 291 opa_vnic_free_mac_tbl(old_mactbl); 292 293 mutex_unlock(&adapter->mactbl_lock); 294 return rc; 295 } 296 297 /* opa_vnic_chk_mac_tbl - check mac table for dlid */ 298 static uint32_t opa_vnic_chk_mac_tbl(struct opa_vnic_adapter *adapter, 299 struct ethhdr *mac_hdr) 300 { 301 struct opa_vnic_mac_tbl_node *node; 302 struct hlist_head *mactbl; 303 u32 dlid = 0; 304 u8 key; 305 306 rcu_read_lock(); 307 mactbl = rcu_dereference(adapter->mactbl); 308 if (unlikely(!mactbl)) 309 goto chk_done; 310 311 key = mac_hdr->h_dest[OPA_VNIC_MAC_HASH_IDX]; 312 vnic_hash_for_each_possible(mactbl, node, hlist, key) { 313 struct __opa_vnic_mactable_entry *entry = &node->entry; 314 315 /* if related to source mac, skip */ 316 if (unlikely(OPA_VNIC_DLID_SD_IS_SRC_MAC(entry->dlid_sd))) 317 continue; 318 319 if (!memcmp(node->entry.mac_addr, mac_hdr->h_dest, 320 ARRAY_SIZE(node->entry.mac_addr))) { 321 /* mac address found */ 322 dlid = OPA_VNIC_DLID_SD_GET_DLID(node->entry.dlid_sd); 323 break; 324 } 325 } 326 327 chk_done: 328 rcu_read_unlock(); 329 return dlid; 330 } 331 332 /* opa_vnic_get_dlid - find and return the DLID */ 333 static uint32_t opa_vnic_get_dlid(struct opa_vnic_adapter *adapter, 334 struct sk_buff *skb, u8 def_port) 335 { 336 struct __opa_veswport_info *info = &adapter->info; 337 struct ethhdr *mac_hdr = (struct ethhdr *)skb_mac_header(skb); 338 u32 dlid; 339 340 dlid = opa_vnic_chk_mac_tbl(adapter, mac_hdr); 341 if (dlid) 342 return dlid; 343 344 if (is_multicast_ether_addr(mac_hdr->h_dest)) { 345 dlid = info->vesw.u_mcast_dlid; 346 } else { 347 if (is_local_ether_addr(mac_hdr->h_dest)) { 348 dlid = ((uint32_t)mac_hdr->h_dest[5] << 16) | 349 ((uint32_t)mac_hdr->h_dest[4] << 8) | 350 mac_hdr->h_dest[3]; 351 if (unlikely(!dlid)) 352 v_warn("Null dlid in MAC address\n"); 353 } else if (def_port != OPA_VNIC_INVALID_PORT) { 354 if (def_port < OPA_VESW_MAX_NUM_DEF_PORT) 355 dlid = info->vesw.u_ucast_dlid[def_port]; 356 } 357 } 358 359 return dlid; 360 } 361 362 /* opa_vnic_get_sc - return the service class */ 363 static u8 opa_vnic_get_sc(struct __opa_veswport_info *info, 364 struct sk_buff *skb) 365 { 366 struct ethhdr *mac_hdr = (struct ethhdr *)skb_mac_header(skb); 367 u16 vlan_tci; 368 u8 sc; 369 370 if (!__vlan_get_tag(skb, &vlan_tci)) { 371 u8 pcp = OPA_VNIC_VLAN_PCP(vlan_tci); 372 373 if (is_multicast_ether_addr(mac_hdr->h_dest)) 374 sc = info->vport.pcp_to_sc_mc[pcp]; 375 else 376 sc = info->vport.pcp_to_sc_uc[pcp]; 377 } else { 378 if (is_multicast_ether_addr(mac_hdr->h_dest)) 379 sc = info->vport.non_vlan_sc_mc; 380 else 381 sc = info->vport.non_vlan_sc_uc; 382 } 383 384 return sc; 385 } 386 387 u8 opa_vnic_get_vl(struct opa_vnic_adapter *adapter, struct sk_buff *skb) 388 { 389 struct ethhdr *mac_hdr = (struct ethhdr *)skb_mac_header(skb); 390 struct __opa_veswport_info *info = &adapter->info; 391 u8 vl; 392 393 if (skb_vlan_tag_present(skb)) { 394 u8 pcp = skb_vlan_tag_get(skb) >> VLAN_PRIO_SHIFT; 395 396 if (is_multicast_ether_addr(mac_hdr->h_dest)) 397 vl = info->vport.pcp_to_vl_mc[pcp]; 398 else 399 vl = info->vport.pcp_to_vl_uc[pcp]; 400 } else { 401 if (is_multicast_ether_addr(mac_hdr->h_dest)) 402 vl = info->vport.non_vlan_vl_mc; 403 else 404 vl = info->vport.non_vlan_vl_uc; 405 } 406 407 return vl; 408 } 409 410 /* opa_vnic_get_rc - return the routing control */ 411 static u8 opa_vnic_get_rc(struct __opa_veswport_info *info, 412 struct sk_buff *skb) 413 { 414 u8 proto, rout_ctrl; 415 416 switch (vlan_get_protocol(skb)) { 417 case htons(ETH_P_IPV6): 418 proto = ipv6_hdr(skb)->nexthdr; 419 if (proto == IPPROTO_TCP) 420 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, 421 IPV6_TCP); 422 else if (proto == IPPROTO_UDP) 423 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, 424 IPV6_UDP); 425 else 426 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, IPV6); 427 break; 428 case htons(ETH_P_IP): 429 proto = ip_hdr(skb)->protocol; 430 if (proto == IPPROTO_TCP) 431 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, 432 IPV4_TCP); 433 else if (proto == IPPROTO_UDP) 434 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, 435 IPV4_UDP); 436 else 437 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, IPV4); 438 break; 439 default: 440 rout_ctrl = OPA_VNIC_ENCAP_RC_EXT(info->vesw.rc, DEFAULT); 441 } 442 443 return rout_ctrl; 444 } 445 446 /* opa_vnic_calc_entropy - calculate the packet entropy */ 447 u8 opa_vnic_calc_entropy(struct sk_buff *skb) 448 { 449 u32 hash = skb_get_hash(skb); 450 451 /* store XOR of all bytes in lower 8 bits */ 452 hash ^= hash >> 8; 453 hash ^= hash >> 16; 454 455 /* return lower 8 bits as entropy */ 456 return (u8)(hash & 0xFF); 457 } 458 459 /* opa_vnic_get_def_port - get default port based on entropy */ 460 static inline u8 opa_vnic_get_def_port(struct opa_vnic_adapter *adapter, 461 u8 entropy) 462 { 463 u8 flow_id; 464 465 /* Add the upper and lower 4-bits of entropy to get the flow id */ 466 flow_id = ((entropy & 0xf) + (entropy >> 4)); 467 return adapter->flow_tbl[flow_id & (OPA_VNIC_FLOW_TBL_SIZE - 1)]; 468 } 469 470 /* Calculate packet length including OPA header, crc and padding */ 471 static inline int opa_vnic_wire_length(struct sk_buff *skb) 472 { 473 u32 pad_len; 474 475 /* padding for 8 bytes size alignment */ 476 pad_len = -(skb->len + OPA_VNIC_ICRC_TAIL_LEN) & 0x7; 477 pad_len += OPA_VNIC_ICRC_TAIL_LEN; 478 479 return (skb->len + pad_len) >> 3; 480 } 481 482 /* opa_vnic_encap_skb - encapsulate skb packet with OPA header and meta data */ 483 void opa_vnic_encap_skb(struct opa_vnic_adapter *adapter, struct sk_buff *skb) 484 { 485 struct __opa_veswport_info *info = &adapter->info; 486 struct opa_vnic_skb_mdata *mdata; 487 u8 def_port, sc, rc, entropy, *hdr; 488 u16 len, l4_hdr; 489 u32 dlid; 490 491 hdr = skb_push(skb, OPA_VNIC_HDR_LEN); 492 493 entropy = opa_vnic_calc_entropy(skb); 494 def_port = opa_vnic_get_def_port(adapter, entropy); 495 len = opa_vnic_wire_length(skb); 496 dlid = opa_vnic_get_dlid(adapter, skb, def_port); 497 sc = opa_vnic_get_sc(info, skb); 498 rc = opa_vnic_get_rc(info, skb); 499 l4_hdr = info->vesw.vesw_id; 500 501 mdata = skb_push(skb, sizeof(*mdata)); 502 mdata->vl = opa_vnic_get_vl(adapter, skb); 503 mdata->entropy = entropy; 504 mdata->flags = 0; 505 if (unlikely(!dlid)) { 506 mdata->flags = OPA_VNIC_SKB_MDATA_ENCAP_ERR; 507 return; 508 } 509 510 opa_vnic_make_header(hdr, info->vport.encap_slid, dlid, len, 511 info->vesw.pkey, entropy, sc, rc, 512 OPA_VNIC_L4_ETHR, l4_hdr); 513 } 514