1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 /* 26 * MAC Services Module - misc utilities 27 */ 28 29 #include <sys/types.h> 30 #include <sys/mac.h> 31 #include <sys/mac_impl.h> 32 #include <sys/mac_client_priv.h> 33 #include <sys/mac_client_impl.h> 34 #include <sys/mac_soft_ring.h> 35 #include <sys/strsubr.h> 36 #include <sys/strsun.h> 37 #include <sys/vlan.h> 38 #include <sys/pattr.h> 39 #include <sys/pci_tools.h> 40 #include <inet/ip.h> 41 #include <inet/ip_impl.h> 42 #include <inet/ip6.h> 43 #include <sys/vtrace.h> 44 #include <sys/dlpi.h> 45 #include <sys/sunndi.h> 46 #include <inet/ipsec_impl.h> 47 #include <inet/sadb.h> 48 #include <inet/ipsecesp.h> 49 #include <inet/ipsecah.h> 50 51 /* 52 * Copy an mblk, preserving its hardware checksum flags. 53 */ 54 static mblk_t * 55 mac_copymsg_cksum(mblk_t *mp) 56 { 57 mblk_t *mp1; 58 uint32_t start, stuff, end, value, flags; 59 60 mp1 = copymsg(mp); 61 if (mp1 == NULL) 62 return (NULL); 63 64 hcksum_retrieve(mp, NULL, NULL, &start, &stuff, &end, &value, &flags); 65 (void) hcksum_assoc(mp1, NULL, NULL, start, stuff, end, value, 66 flags, KM_NOSLEEP); 67 68 return (mp1); 69 } 70 71 /* 72 * Copy an mblk chain, presenting the hardware checksum flags of the 73 * individual mblks. 74 */ 75 mblk_t * 76 mac_copymsgchain_cksum(mblk_t *mp) 77 { 78 mblk_t *nmp = NULL; 79 mblk_t **nmpp = &nmp; 80 81 for (; mp != NULL; mp = mp->b_next) { 82 if ((*nmpp = mac_copymsg_cksum(mp)) == NULL) { 83 freemsgchain(nmp); 84 return (NULL); 85 } 86 87 nmpp = &((*nmpp)->b_next); 88 } 89 90 return (nmp); 91 } 92 93 /* 94 * Process the specified mblk chain for proper handling of hardware 95 * checksum offload. This routine is invoked for loopback traffic 96 * between MAC clients. 97 * The function handles a NULL mblk chain passed as argument. 98 */ 99 mblk_t * 100 mac_fix_cksum(mblk_t *mp_chain) 101 { 102 mblk_t *mp, *prev = NULL, *new_chain = mp_chain, *mp1; 103 uint32_t flags, start, stuff, end, value; 104 105 for (mp = mp_chain; mp != NULL; prev = mp, mp = mp->b_next) { 106 uint16_t len; 107 uint32_t offset; 108 struct ether_header *ehp; 109 uint16_t sap; 110 111 hcksum_retrieve(mp, NULL, NULL, &start, &stuff, &end, &value, 112 &flags); 113 if (flags == 0) 114 continue; 115 116 /* 117 * Since the processing of checksum offload for loopback 118 * traffic requires modification of the packet contents, 119 * ensure sure that we are always modifying our own copy. 120 */ 121 if (DB_REF(mp) > 1) { 122 mp1 = copymsg(mp); 123 if (mp1 == NULL) 124 continue; 125 mp1->b_next = mp->b_next; 126 mp->b_next = NULL; 127 freemsg(mp); 128 if (prev != NULL) 129 prev->b_next = mp1; 130 else 131 new_chain = mp1; 132 mp = mp1; 133 } 134 135 /* 136 * Ethernet, and optionally VLAN header. 137 */ 138 /* LINTED: improper alignment cast */ 139 ehp = (struct ether_header *)mp->b_rptr; 140 if (ntohs(ehp->ether_type) == VLAN_TPID) { 141 struct ether_vlan_header *evhp; 142 143 ASSERT(MBLKL(mp) >= sizeof (struct ether_vlan_header)); 144 /* LINTED: improper alignment cast */ 145 evhp = (struct ether_vlan_header *)mp->b_rptr; 146 sap = ntohs(evhp->ether_type); 147 offset = sizeof (struct ether_vlan_header); 148 } else { 149 sap = ntohs(ehp->ether_type); 150 offset = sizeof (struct ether_header); 151 } 152 153 if (MBLKL(mp) <= offset) { 154 offset -= MBLKL(mp); 155 if (mp->b_cont == NULL) { 156 /* corrupted packet, skip it */ 157 if (prev != NULL) 158 prev->b_next = mp->b_next; 159 else 160 new_chain = mp->b_next; 161 mp1 = mp->b_next; 162 mp->b_next = NULL; 163 freemsg(mp); 164 mp = mp1; 165 continue; 166 } 167 mp = mp->b_cont; 168 } 169 170 if (flags & (HCK_FULLCKSUM | HCK_IPV4_HDRCKSUM)) { 171 ipha_t *ipha = NULL; 172 173 /* 174 * In order to compute the full and header 175 * checksums, we need to find and parse 176 * the IP and/or ULP headers. 177 */ 178 179 sap = (sap < ETHERTYPE_802_MIN) ? 0 : sap; 180 181 /* 182 * IP header. 183 */ 184 if (sap != ETHERTYPE_IP) 185 continue; 186 187 ASSERT(MBLKL(mp) >= offset + sizeof (ipha_t)); 188 /* LINTED: improper alignment cast */ 189 ipha = (ipha_t *)(mp->b_rptr + offset); 190 191 if (flags & HCK_FULLCKSUM) { 192 ipaddr_t src, dst; 193 uint32_t cksum; 194 uint16_t *up; 195 uint8_t proto; 196 197 /* 198 * Pointer to checksum field in ULP header. 199 */ 200 proto = ipha->ipha_protocol; 201 ASSERT(ipha->ipha_version_and_hdr_length == 202 IP_SIMPLE_HDR_VERSION); 203 204 switch (proto) { 205 case IPPROTO_TCP: 206 /* LINTED: improper alignment cast */ 207 up = IPH_TCPH_CHECKSUMP(ipha, 208 IP_SIMPLE_HDR_LENGTH); 209 break; 210 211 case IPPROTO_UDP: 212 /* LINTED: improper alignment cast */ 213 up = IPH_UDPH_CHECKSUMP(ipha, 214 IP_SIMPLE_HDR_LENGTH); 215 break; 216 217 default: 218 cmn_err(CE_WARN, "mac_fix_cksum: " 219 "unexpected protocol: %d", proto); 220 continue; 221 } 222 223 /* 224 * Pseudo-header checksum. 225 */ 226 src = ipha->ipha_src; 227 dst = ipha->ipha_dst; 228 len = ntohs(ipha->ipha_length) - 229 IP_SIMPLE_HDR_LENGTH; 230 231 cksum = (dst >> 16) + (dst & 0xFFFF) + 232 (src >> 16) + (src & 0xFFFF); 233 cksum += htons(len); 234 235 /* 236 * The checksum value stored in the packet needs 237 * to be correct. Compute it here. 238 */ 239 *up = 0; 240 cksum += (((proto) == IPPROTO_UDP) ? 241 IP_UDP_CSUM_COMP : IP_TCP_CSUM_COMP); 242 cksum = IP_CSUM(mp, IP_SIMPLE_HDR_LENGTH + 243 offset, cksum); 244 *(up) = (uint16_t)(cksum ? cksum : ~cksum); 245 246 /* 247 * Flag the packet so that it appears 248 * that the checksum has already been 249 * verified by the hardware. 250 */ 251 flags &= ~HCK_FULLCKSUM; 252 flags |= HCK_FULLCKSUM_OK; 253 value = 0; 254 } 255 256 if (flags & HCK_IPV4_HDRCKSUM) { 257 ASSERT(ipha != NULL); 258 ipha->ipha_hdr_checksum = 259 (uint16_t)ip_csum_hdr(ipha); 260 flags &= ~HCK_IPV4_HDRCKSUM; 261 flags |= HCK_IPV4_HDRCKSUM_OK; 262 263 } 264 } 265 266 if (flags & HCK_PARTIALCKSUM) { 267 uint16_t *up, partial, cksum; 268 uchar_t *ipp; /* ptr to beginning of IP header */ 269 270 if (mp->b_cont != NULL) { 271 mblk_t *mp1; 272 273 mp1 = msgpullup(mp, offset + end); 274 if (mp1 == NULL) 275 continue; 276 mp1->b_next = mp->b_next; 277 mp->b_next = NULL; 278 freemsg(mp); 279 if (prev != NULL) 280 prev->b_next = mp1; 281 else 282 new_chain = mp1; 283 mp = mp1; 284 } 285 286 ipp = mp->b_rptr + offset; 287 /* LINTED: cast may result in improper alignment */ 288 up = (uint16_t *)((uchar_t *)ipp + stuff); 289 partial = *up; 290 *up = 0; 291 292 cksum = IP_BCSUM_PARTIAL(mp->b_rptr + offset + start, 293 end - start, partial); 294 cksum = ~cksum; 295 *up = cksum ? cksum : ~cksum; 296 297 /* 298 * Since we already computed the whole checksum, 299 * indicate to the stack that it has already 300 * been verified by the hardware. 301 */ 302 flags &= ~HCK_PARTIALCKSUM; 303 flags |= HCK_FULLCKSUM_OK; 304 value = 0; 305 } 306 307 (void) hcksum_assoc(mp, NULL, NULL, start, stuff, end, 308 value, flags, KM_NOSLEEP); 309 } 310 311 return (new_chain); 312 } 313 314 /* 315 * Add VLAN tag to the specified mblk. 316 */ 317 mblk_t * 318 mac_add_vlan_tag(mblk_t *mp, uint_t pri, uint16_t vid) 319 { 320 mblk_t *hmp; 321 struct ether_vlan_header *evhp; 322 struct ether_header *ehp; 323 uint32_t start, stuff, end, value, flags; 324 325 ASSERT(pri != 0 || vid != 0); 326 327 /* 328 * Allocate an mblk for the new tagged ethernet header, 329 * and copy the MAC addresses and ethertype from the 330 * original header. 331 */ 332 333 hmp = allocb(sizeof (struct ether_vlan_header), BPRI_MED); 334 if (hmp == NULL) { 335 freemsg(mp); 336 return (NULL); 337 } 338 339 evhp = (struct ether_vlan_header *)hmp->b_rptr; 340 ehp = (struct ether_header *)mp->b_rptr; 341 342 bcopy(ehp, evhp, (ETHERADDRL * 2)); 343 evhp->ether_type = ehp->ether_type; 344 evhp->ether_tpid = htons(ETHERTYPE_VLAN); 345 346 hmp->b_wptr += sizeof (struct ether_vlan_header); 347 mp->b_rptr += sizeof (struct ether_header); 348 349 /* 350 * Free the original message if it's now empty. Link the 351 * rest of messages to the header message. 352 */ 353 hcksum_retrieve(mp, NULL, NULL, &start, &stuff, &end, &value, &flags); 354 (void) hcksum_assoc(hmp, NULL, NULL, start, stuff, end, value, flags, 355 KM_NOSLEEP); 356 if (MBLKL(mp) == 0) { 357 hmp->b_cont = mp->b_cont; 358 freeb(mp); 359 } else { 360 hmp->b_cont = mp; 361 } 362 ASSERT(MBLKL(hmp) >= sizeof (struct ether_vlan_header)); 363 364 /* 365 * Initialize the new TCI (Tag Control Information). 366 */ 367 evhp->ether_tci = htons(VLAN_TCI(pri, 0, vid)); 368 369 return (hmp); 370 } 371 372 /* 373 * Adds a VLAN tag with the specified VID and priority to each mblk of 374 * the specified chain. 375 */ 376 mblk_t * 377 mac_add_vlan_tag_chain(mblk_t *mp_chain, uint_t pri, uint16_t vid) 378 { 379 mblk_t *next_mp, **prev, *mp; 380 381 mp = mp_chain; 382 prev = &mp_chain; 383 384 while (mp != NULL) { 385 next_mp = mp->b_next; 386 mp->b_next = NULL; 387 if ((mp = mac_add_vlan_tag(mp, pri, vid)) == NULL) { 388 freemsgchain(next_mp); 389 break; 390 } 391 *prev = mp; 392 prev = &mp->b_next; 393 mp = mp->b_next = next_mp; 394 } 395 396 return (mp_chain); 397 } 398 399 /* 400 * Strip VLAN tag 401 */ 402 mblk_t * 403 mac_strip_vlan_tag(mblk_t *mp) 404 { 405 mblk_t *newmp; 406 struct ether_vlan_header *evhp; 407 408 evhp = (struct ether_vlan_header *)mp->b_rptr; 409 if (ntohs(evhp->ether_tpid) == ETHERTYPE_VLAN) { 410 ASSERT(MBLKL(mp) >= sizeof (struct ether_vlan_header)); 411 412 if (DB_REF(mp) > 1) { 413 newmp = copymsg(mp); 414 if (newmp == NULL) 415 return (NULL); 416 freemsg(mp); 417 mp = newmp; 418 } 419 420 evhp = (struct ether_vlan_header *)mp->b_rptr; 421 422 ovbcopy(mp->b_rptr, mp->b_rptr + VLAN_TAGSZ, 2 * ETHERADDRL); 423 mp->b_rptr += VLAN_TAGSZ; 424 } 425 return (mp); 426 } 427 428 /* 429 * Strip VLAN tag from each mblk of the chain. 430 */ 431 mblk_t * 432 mac_strip_vlan_tag_chain(mblk_t *mp_chain) 433 { 434 mblk_t *mp, *next_mp, **prev; 435 436 mp = mp_chain; 437 prev = &mp_chain; 438 439 while (mp != NULL) { 440 next_mp = mp->b_next; 441 mp->b_next = NULL; 442 if ((mp = mac_strip_vlan_tag(mp)) == NULL) { 443 freemsgchain(next_mp); 444 break; 445 } 446 *prev = mp; 447 prev = &mp->b_next; 448 mp = mp->b_next = next_mp; 449 } 450 451 return (mp_chain); 452 } 453 454 /* 455 * Default callback function. Used when the datapath is not yet initialized. 456 */ 457 /* ARGSUSED */ 458 void 459 mac_pkt_drop(void *arg, mac_resource_handle_t resource, mblk_t *mp, 460 boolean_t loopback) 461 { 462 mblk_t *mp1 = mp; 463 464 while (mp1 != NULL) { 465 mp1->b_prev = NULL; 466 mp1->b_queue = NULL; 467 mp1 = mp1->b_next; 468 } 469 freemsgchain(mp); 470 } 471 472 /* 473 * Determines the IPv6 header length accounting for all the optional IPv6 474 * headers (hop-by-hop, destination, routing and fragment). The header length 475 * and next header value (a transport header) is captured. 476 * 477 * Returns B_FALSE if all the IP headers are not in the same mblk otherwise 478 * returns B_TRUE. 479 */ 480 boolean_t 481 mac_ip_hdr_length_v6(ip6_t *ip6h, uint8_t *endptr, uint16_t *hdr_length, 482 uint8_t *next_hdr, ip6_frag_t **fragp) 483 { 484 uint16_t length; 485 uint_t ehdrlen; 486 uint8_t *whereptr; 487 uint8_t *nexthdrp; 488 ip6_dest_t *desthdr; 489 ip6_rthdr_t *rthdr; 490 ip6_frag_t *fraghdr; 491 492 if (((uchar_t *)ip6h + IPV6_HDR_LEN) > endptr) 493 return (B_FALSE); 494 ASSERT(IPH_HDR_VERSION(ip6h) == IPV6_VERSION); 495 length = IPV6_HDR_LEN; 496 whereptr = ((uint8_t *)&ip6h[1]); /* point to next hdr */ 497 498 if (fragp != NULL) 499 *fragp = NULL; 500 501 nexthdrp = &ip6h->ip6_nxt; 502 while (whereptr < endptr) { 503 /* Is there enough left for len + nexthdr? */ 504 if (whereptr + MIN_EHDR_LEN > endptr) 505 break; 506 507 switch (*nexthdrp) { 508 case IPPROTO_HOPOPTS: 509 case IPPROTO_DSTOPTS: 510 /* Assumes the headers are identical for hbh and dst */ 511 desthdr = (ip6_dest_t *)whereptr; 512 ehdrlen = 8 * (desthdr->ip6d_len + 1); 513 if ((uchar_t *)desthdr + ehdrlen > endptr) 514 return (B_FALSE); 515 nexthdrp = &desthdr->ip6d_nxt; 516 break; 517 case IPPROTO_ROUTING: 518 rthdr = (ip6_rthdr_t *)whereptr; 519 ehdrlen = 8 * (rthdr->ip6r_len + 1); 520 if ((uchar_t *)rthdr + ehdrlen > endptr) 521 return (B_FALSE); 522 nexthdrp = &rthdr->ip6r_nxt; 523 break; 524 case IPPROTO_FRAGMENT: 525 fraghdr = (ip6_frag_t *)whereptr; 526 ehdrlen = sizeof (ip6_frag_t); 527 if ((uchar_t *)&fraghdr[1] > endptr) 528 return (B_FALSE); 529 nexthdrp = &fraghdr->ip6f_nxt; 530 if (fragp != NULL) 531 *fragp = fraghdr; 532 break; 533 case IPPROTO_NONE: 534 /* No next header means we're finished */ 535 default: 536 *hdr_length = length; 537 *next_hdr = *nexthdrp; 538 return (B_TRUE); 539 } 540 length += ehdrlen; 541 whereptr += ehdrlen; 542 *hdr_length = length; 543 *next_hdr = *nexthdrp; 544 } 545 switch (*nexthdrp) { 546 case IPPROTO_HOPOPTS: 547 case IPPROTO_DSTOPTS: 548 case IPPROTO_ROUTING: 549 case IPPROTO_FRAGMENT: 550 /* 551 * If any know extension headers are still to be processed, 552 * the packet's malformed (or at least all the IP header(s) are 553 * not in the same mblk - and that should never happen. 554 */ 555 return (B_FALSE); 556 557 default: 558 /* 559 * If we get here, we know that all of the IP headers were in 560 * the same mblk, even if the ULP header is in the next mblk. 561 */ 562 *hdr_length = length; 563 *next_hdr = *nexthdrp; 564 return (B_TRUE); 565 } 566 } 567 568 /* 569 * The following set of routines are there to take care of interrupt 570 * re-targeting for legacy (fixed) interrupts. Some older versions 571 * of the popular NICs like e1000g do not support MSI-X interrupts 572 * and they reserve fixed interrupts for RX/TX rings. To re-target 573 * these interrupts, PCITOOL ioctls need to be used. 574 */ 575 typedef struct mac_dladm_intr { 576 int ino; 577 int cpu_id; 578 char driver_path[MAXPATHLEN]; 579 char nexus_path[MAXPATHLEN]; 580 } mac_dladm_intr_t; 581 582 /* Bind the interrupt to cpu_num */ 583 static int 584 mac_set_intr(ldi_handle_t lh, processorid_t cpu_num, int oldcpuid, int ino) 585 { 586 pcitool_intr_set_t iset; 587 int err; 588 589 iset.old_cpu = oldcpuid; 590 iset.ino = ino; 591 iset.cpu_id = cpu_num; 592 iset.user_version = PCITOOL_VERSION; 593 err = ldi_ioctl(lh, PCITOOL_DEVICE_SET_INTR, (intptr_t)&iset, FKIOCTL, 594 kcred, NULL); 595 596 return (err); 597 } 598 599 /* 600 * Search interrupt information. iget is filled in with the info to search 601 */ 602 static boolean_t 603 mac_search_intrinfo(pcitool_intr_get_t *iget_p, mac_dladm_intr_t *dln) 604 { 605 int i; 606 char driver_path[2 * MAXPATHLEN]; 607 608 for (i = 0; i < iget_p->num_devs; i++) { 609 (void) strlcpy(driver_path, iget_p->dev[i].path, MAXPATHLEN); 610 (void) snprintf(&driver_path[strlen(driver_path)], MAXPATHLEN, 611 ":%s%d", iget_p->dev[i].driver_name, 612 iget_p->dev[i].dev_inst); 613 /* Match the device path for the device path */ 614 if (strcmp(driver_path, dln->driver_path) == 0) { 615 dln->ino = iget_p->ino; 616 dln->cpu_id = iget_p->cpu_id; 617 return (B_TRUE); 618 } 619 } 620 return (B_FALSE); 621 } 622 623 /* 624 * Get information about ino, i.e. if this is the interrupt for our 625 * device and where it is bound etc. 626 */ 627 static boolean_t 628 mac_get_single_intr(ldi_handle_t lh, int oldcpuid, int ino, 629 mac_dladm_intr_t *dln) 630 { 631 pcitool_intr_get_t *iget_p; 632 int ipsz; 633 int nipsz; 634 int err; 635 uint8_t inum; 636 637 /* 638 * Check if SLEEP is OK, i.e if could come here in response to 639 * changing the fanout due to some callback from the driver, say 640 * link speed changes. 641 */ 642 ipsz = PCITOOL_IGET_SIZE(0); 643 iget_p = kmem_zalloc(ipsz, KM_SLEEP); 644 645 iget_p->num_devs_ret = 0; 646 iget_p->user_version = PCITOOL_VERSION; 647 iget_p->cpu_id = oldcpuid; 648 iget_p->ino = ino; 649 650 err = ldi_ioctl(lh, PCITOOL_DEVICE_GET_INTR, (intptr_t)iget_p, 651 FKIOCTL, kcred, NULL); 652 if (err != 0) { 653 kmem_free(iget_p, ipsz); 654 return (B_FALSE); 655 } 656 if (iget_p->num_devs == 0) { 657 kmem_free(iget_p, ipsz); 658 return (B_FALSE); 659 } 660 inum = iget_p->num_devs; 661 if (iget_p->num_devs_ret < iget_p->num_devs) { 662 /* Reallocate */ 663 nipsz = PCITOOL_IGET_SIZE(iget_p->num_devs); 664 665 kmem_free(iget_p, ipsz); 666 ipsz = nipsz; 667 iget_p = kmem_zalloc(ipsz, KM_SLEEP); 668 669 iget_p->num_devs_ret = inum; 670 iget_p->cpu_id = oldcpuid; 671 iget_p->ino = ino; 672 iget_p->user_version = PCITOOL_VERSION; 673 err = ldi_ioctl(lh, PCITOOL_DEVICE_GET_INTR, (intptr_t)iget_p, 674 FKIOCTL, kcred, NULL); 675 if (err != 0) { 676 kmem_free(iget_p, ipsz); 677 return (B_FALSE); 678 } 679 /* defensive */ 680 if (iget_p->num_devs != iget_p->num_devs_ret) { 681 kmem_free(iget_p, ipsz); 682 return (B_FALSE); 683 } 684 } 685 686 if (mac_search_intrinfo(iget_p, dln)) { 687 kmem_free(iget_p, ipsz); 688 return (B_TRUE); 689 } 690 kmem_free(iget_p, ipsz); 691 return (B_FALSE); 692 } 693 694 /* 695 * Get the interrupts and check each one to see if it is for our device. 696 */ 697 static int 698 mac_validate_intr(ldi_handle_t lh, mac_dladm_intr_t *dln, processorid_t cpuid) 699 { 700 pcitool_intr_info_t intr_info; 701 int err; 702 int ino; 703 int oldcpuid; 704 705 err = ldi_ioctl(lh, PCITOOL_SYSTEM_INTR_INFO, (intptr_t)&intr_info, 706 FKIOCTL, kcred, NULL); 707 if (err != 0) 708 return (-1); 709 710 for (oldcpuid = 0; oldcpuid < intr_info.num_cpu; oldcpuid++) { 711 for (ino = 0; ino < intr_info.num_intr; ino++) { 712 if (mac_get_single_intr(lh, oldcpuid, ino, dln)) { 713 if (dln->cpu_id == cpuid) 714 return (0); 715 return (1); 716 } 717 } 718 } 719 return (-1); 720 } 721 722 /* 723 * Obtain the nexus parent node info. for mdip. 724 */ 725 static dev_info_t * 726 mac_get_nexus_node(dev_info_t *mdip, mac_dladm_intr_t *dln) 727 { 728 struct dev_info *tdip = (struct dev_info *)mdip; 729 struct ddi_minor_data *minordata; 730 int circ; 731 dev_info_t *pdip; 732 char pathname[MAXPATHLEN]; 733 734 while (tdip != NULL) { 735 /* 736 * The netboot code could call this function while walking the 737 * device tree so we need to use ndi_devi_tryenter() here to 738 * avoid deadlock. 739 */ 740 if (ndi_devi_tryenter((dev_info_t *)tdip, &circ) == 0) 741 break; 742 743 for (minordata = tdip->devi_minor; minordata != NULL; 744 minordata = minordata->next) { 745 if (strncmp(minordata->ddm_node_type, DDI_NT_INTRCTL, 746 strlen(DDI_NT_INTRCTL)) == 0) { 747 pdip = minordata->dip; 748 (void) ddi_pathname(pdip, pathname); 749 (void) snprintf(dln->nexus_path, MAXPATHLEN, 750 "/devices%s:intr", pathname); 751 (void) ddi_pathname_minor(minordata, pathname); 752 ndi_devi_exit((dev_info_t *)tdip, circ); 753 return (pdip); 754 } 755 } 756 ndi_devi_exit((dev_info_t *)tdip, circ); 757 tdip = tdip->devi_parent; 758 } 759 return (NULL); 760 } 761 762 /* 763 * For a primary MAC client, if the user has set a list or CPUs or 764 * we have obtained it implicitly, we try to retarget the interrupt 765 * for that device on one of the CPUs in the list. 766 * We assign the interrupt to the same CPU as the poll thread. 767 */ 768 static boolean_t 769 mac_check_interrupt_binding(dev_info_t *mdip, int32_t cpuid) 770 { 771 ldi_handle_t lh = NULL; 772 ldi_ident_t li = NULL; 773 int err; 774 int ret; 775 mac_dladm_intr_t dln; 776 dev_info_t *dip; 777 struct ddi_minor_data *minordata; 778 779 dln.nexus_path[0] = '\0'; 780 dln.driver_path[0] = '\0'; 781 782 minordata = ((struct dev_info *)mdip)->devi_minor; 783 while (minordata != NULL) { 784 if (minordata->type == DDM_MINOR) 785 break; 786 minordata = minordata->next; 787 } 788 if (minordata == NULL) 789 return (B_FALSE); 790 791 (void) ddi_pathname_minor(minordata, dln.driver_path); 792 793 dip = mac_get_nexus_node(mdip, &dln); 794 /* defensive */ 795 if (dip == NULL) 796 return (B_FALSE); 797 798 err = ldi_ident_from_major(ddi_driver_major(dip), &li); 799 if (err != 0) 800 return (B_FALSE); 801 802 err = ldi_open_by_name(dln.nexus_path, FREAD|FWRITE, kcred, &lh, li); 803 if (err != 0) 804 return (B_FALSE); 805 806 ret = mac_validate_intr(lh, &dln, cpuid); 807 if (ret < 0) { 808 (void) ldi_close(lh, FREAD|FWRITE, kcred); 809 return (B_FALSE); 810 } 811 /* cmn_note? */ 812 if (ret != 0) 813 if ((err = (mac_set_intr(lh, cpuid, dln.cpu_id, dln.ino))) 814 != 0) { 815 (void) ldi_close(lh, FREAD|FWRITE, kcred); 816 return (B_FALSE); 817 } 818 (void) ldi_close(lh, FREAD|FWRITE, kcred); 819 return (B_TRUE); 820 } 821 822 void 823 mac_client_set_intr_cpu(void *arg, mac_client_handle_t mch, int32_t cpuid) 824 { 825 dev_info_t *mdip = (dev_info_t *)arg; 826 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 827 mac_resource_props_t *mrp; 828 mac_perim_handle_t mph; 829 flow_entry_t *flent = mcip->mci_flent; 830 mac_soft_ring_set_t *rx_srs; 831 mac_cpus_t *srs_cpu; 832 833 if (!mac_check_interrupt_binding(mdip, cpuid)) 834 cpuid = -1; 835 mac_perim_enter_by_mh((mac_handle_t)mcip->mci_mip, &mph); 836 mrp = MCIP_RESOURCE_PROPS(mcip); 837 mrp->mrp_rx_intr_cpu = cpuid; 838 if (flent != NULL && flent->fe_rx_srs_cnt == 2) { 839 rx_srs = flent->fe_rx_srs[1]; 840 srs_cpu = &rx_srs->srs_cpu; 841 srs_cpu->mc_rx_intr_cpu = cpuid; 842 } 843 mac_perim_exit(mph); 844 } 845 846 int32_t 847 mac_client_intr_cpu(mac_client_handle_t mch) 848 { 849 mac_client_impl_t *mcip = (mac_client_impl_t *)mch; 850 mac_cpus_t *srs_cpu; 851 mac_soft_ring_set_t *rx_srs; 852 flow_entry_t *flent = mcip->mci_flent; 853 mac_resource_props_t *mrp = MCIP_RESOURCE_PROPS(mcip); 854 mac_ring_t *ring; 855 mac_intr_t *mintr; 856 857 /* 858 * Check if we need to retarget the interrupt. We do this only 859 * for the primary MAC client. We do this if we have the only 860 * exclusive ring in the group. 861 */ 862 if (mac_is_primary_client(mcip) && flent->fe_rx_srs_cnt == 2) { 863 rx_srs = flent->fe_rx_srs[1]; 864 srs_cpu = &rx_srs->srs_cpu; 865 ring = rx_srs->srs_ring; 866 mintr = &ring->mr_info.mri_intr; 867 /* 868 * If ddi_handle is present or the poll CPU is 869 * already bound to the interrupt CPU, return -1. 870 */ 871 if (mintr->mi_ddi_handle != NULL || 872 ((mrp->mrp_ncpus != 0) && 873 (mrp->mrp_rx_intr_cpu == srs_cpu->mc_rx_pollid))) { 874 return (-1); 875 } 876 return (srs_cpu->mc_rx_pollid); 877 } 878 return (-1); 879 } 880 881 void * 882 mac_get_devinfo(mac_handle_t mh) 883 { 884 mac_impl_t *mip = (mac_impl_t *)mh; 885 886 return ((void *)mip->mi_dip); 887 } 888 889 #define PKT_HASH_2BYTES(x) ((x)[0] ^ (x)[1]) 890 #define PKT_HASH_4BYTES(x) ((x)[0] ^ (x)[1] ^ (x)[2] ^ (x)[3]) 891 #define PKT_HASH_MAC(x) ((x)[0] ^ (x)[1] ^ (x)[2] ^ (x)[3] ^ (x)[4] ^ (x)[5]) 892 893 uint64_t 894 mac_pkt_hash(uint_t media, mblk_t *mp, uint8_t policy, boolean_t is_outbound) 895 { 896 struct ether_header *ehp; 897 uint64_t hash = 0; 898 uint16_t sap; 899 uint_t skip_len; 900 uint8_t proto; 901 boolean_t ip_fragmented; 902 903 /* 904 * We may want to have one of these per MAC type plugin in the 905 * future. For now supports only ethernet. 906 */ 907 if (media != DL_ETHER) 908 return (0L); 909 910 /* for now we support only outbound packets */ 911 ASSERT(is_outbound); 912 ASSERT(IS_P2ALIGNED(mp->b_rptr, sizeof (uint16_t))); 913 ASSERT(MBLKL(mp) >= sizeof (struct ether_header)); 914 915 /* compute L2 hash */ 916 917 ehp = (struct ether_header *)mp->b_rptr; 918 919 if ((policy & MAC_PKT_HASH_L2) != 0) { 920 uchar_t *mac_src = ehp->ether_shost.ether_addr_octet; 921 uchar_t *mac_dst = ehp->ether_dhost.ether_addr_octet; 922 hash = PKT_HASH_MAC(mac_src) ^ PKT_HASH_MAC(mac_dst); 923 policy &= ~MAC_PKT_HASH_L2; 924 } 925 926 if (policy == 0) 927 goto done; 928 929 /* skip ethernet header */ 930 931 sap = ntohs(ehp->ether_type); 932 if (sap == ETHERTYPE_VLAN) { 933 struct ether_vlan_header *evhp; 934 mblk_t *newmp = NULL; 935 936 skip_len = sizeof (struct ether_vlan_header); 937 if (MBLKL(mp) < skip_len) { 938 /* the vlan tag is the payload, pull up first */ 939 newmp = msgpullup(mp, -1); 940 if ((newmp == NULL) || (MBLKL(newmp) < skip_len)) { 941 goto done; 942 } 943 evhp = (struct ether_vlan_header *)newmp->b_rptr; 944 } else { 945 evhp = (struct ether_vlan_header *)mp->b_rptr; 946 } 947 948 sap = ntohs(evhp->ether_type); 949 freemsg(newmp); 950 } else { 951 skip_len = sizeof (struct ether_header); 952 } 953 954 /* if ethernet header is in its own mblk, skip it */ 955 if (MBLKL(mp) <= skip_len) { 956 skip_len -= MBLKL(mp); 957 mp = mp->b_cont; 958 if (mp == NULL) 959 goto done; 960 } 961 962 sap = (sap < ETHERTYPE_802_MIN) ? 0 : sap; 963 964 /* compute IP src/dst addresses hash and skip IPv{4,6} header */ 965 966 switch (sap) { 967 case ETHERTYPE_IP: { 968 ipha_t *iphp; 969 970 /* 971 * If the header is not aligned or the header doesn't fit 972 * in the mblk, bail now. Note that this may cause packets 973 * reordering. 974 */ 975 iphp = (ipha_t *)(mp->b_rptr + skip_len); 976 if (((unsigned char *)iphp + sizeof (ipha_t) > mp->b_wptr) || 977 !OK_32PTR((char *)iphp)) 978 goto done; 979 980 proto = iphp->ipha_protocol; 981 skip_len += IPH_HDR_LENGTH(iphp); 982 983 /* Check if the packet is fragmented. */ 984 ip_fragmented = ntohs(iphp->ipha_fragment_offset_and_flags) & 985 IPH_OFFSET; 986 987 /* 988 * For fragmented packets, use addresses in addition to 989 * the frag_id to generate the hash inorder to get 990 * better distribution. 991 */ 992 if (ip_fragmented || (policy & MAC_PKT_HASH_L3) != 0) { 993 uint8_t *ip_src = (uint8_t *)&(iphp->ipha_src); 994 uint8_t *ip_dst = (uint8_t *)&(iphp->ipha_dst); 995 996 hash ^= (PKT_HASH_4BYTES(ip_src) ^ 997 PKT_HASH_4BYTES(ip_dst)); 998 policy &= ~MAC_PKT_HASH_L3; 999 } 1000 1001 if (ip_fragmented) { 1002 uint8_t *identp = (uint8_t *)&iphp->ipha_ident; 1003 hash ^= PKT_HASH_2BYTES(identp); 1004 goto done; 1005 } 1006 break; 1007 } 1008 case ETHERTYPE_IPV6: { 1009 ip6_t *ip6hp; 1010 ip6_frag_t *frag = NULL; 1011 uint16_t hdr_length; 1012 1013 /* 1014 * If the header is not aligned or the header doesn't fit 1015 * in the mblk, bail now. Note that this may cause packets 1016 * reordering. 1017 */ 1018 1019 ip6hp = (ip6_t *)(mp->b_rptr + skip_len); 1020 if (((unsigned char *)ip6hp + IPV6_HDR_LEN > mp->b_wptr) || 1021 !OK_32PTR((char *)ip6hp)) 1022 goto done; 1023 1024 if (!mac_ip_hdr_length_v6(ip6hp, mp->b_wptr, &hdr_length, 1025 &proto, &frag)) 1026 goto done; 1027 skip_len += hdr_length; 1028 1029 /* 1030 * For fragmented packets, use addresses in addition to 1031 * the frag_id to generate the hash inorder to get 1032 * better distribution. 1033 */ 1034 if (frag != NULL || (policy & MAC_PKT_HASH_L3) != 0) { 1035 uint8_t *ip_src = &(ip6hp->ip6_src.s6_addr8[12]); 1036 uint8_t *ip_dst = &(ip6hp->ip6_dst.s6_addr8[12]); 1037 1038 hash ^= (PKT_HASH_4BYTES(ip_src) ^ 1039 PKT_HASH_4BYTES(ip_dst)); 1040 policy &= ~MAC_PKT_HASH_L3; 1041 } 1042 1043 if (frag != NULL) { 1044 uint8_t *identp = (uint8_t *)&frag->ip6f_ident; 1045 hash ^= PKT_HASH_4BYTES(identp); 1046 goto done; 1047 } 1048 break; 1049 } 1050 default: 1051 goto done; 1052 } 1053 1054 if (policy == 0) 1055 goto done; 1056 1057 /* if ip header is in its own mblk, skip it */ 1058 if (MBLKL(mp) <= skip_len) { 1059 skip_len -= MBLKL(mp); 1060 mp = mp->b_cont; 1061 if (mp == NULL) 1062 goto done; 1063 } 1064 1065 /* parse ULP header */ 1066 again: 1067 switch (proto) { 1068 case IPPROTO_TCP: 1069 case IPPROTO_UDP: 1070 case IPPROTO_ESP: 1071 case IPPROTO_SCTP: 1072 /* 1073 * These Internet Protocols are intentionally designed 1074 * for hashing from the git-go. Port numbers are in the first 1075 * word for transports, SPI is first for ESP. 1076 */ 1077 if (mp->b_rptr + skip_len + 4 > mp->b_wptr) 1078 goto done; 1079 hash ^= PKT_HASH_4BYTES((mp->b_rptr + skip_len)); 1080 break; 1081 1082 case IPPROTO_AH: { 1083 ah_t *ah = (ah_t *)(mp->b_rptr + skip_len); 1084 uint_t ah_length = AH_TOTAL_LEN(ah); 1085 1086 if ((unsigned char *)ah + sizeof (ah_t) > mp->b_wptr) 1087 goto done; 1088 1089 proto = ah->ah_nexthdr; 1090 skip_len += ah_length; 1091 1092 /* if AH header is in its own mblk, skip it */ 1093 if (MBLKL(mp) <= skip_len) { 1094 skip_len -= MBLKL(mp); 1095 mp = mp->b_cont; 1096 if (mp == NULL) 1097 goto done; 1098 } 1099 1100 goto again; 1101 } 1102 } 1103 1104 done: 1105 return (hash); 1106 } 1107