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  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  22  * Use is subject to license terms.
  23  */
  24 
  25 #pragma ident   "%Z%%M% %I%     %E% SMI"
  26 
  27 /*
  28  * gld - Generic LAN Driver
  29  * media dependent routines
  30  */
  31 
  32 #include <sys/types.h>
  33 #include <sys/errno.h>
  34 #include <sys/stropts.h>
  35 #include <sys/stream.h>
  36 #include <sys/kmem.h>
  37 #include <sys/stat.h>
  38 #include <sys/modctl.h>
  39 #include <sys/kstat.h>
  40 #include <sys/debug.h>
  41 
  42 #include <sys/byteorder.h>
  43 #include <sys/strsun.h>
  44 #include <sys/dlpi.h>
  45 #include <sys/ethernet.h>
  46 #include <sys/multidata.h>
  47 #include <sys/gld.h>
  48 #include <sys/gldpriv.h>
  49 #include <sys/ddi.h>
  50 #include <sys/sunddi.h>
  51 #include <sys/sysmacros.h>
  52 #include <sys/ib/clients/ibd/ibd.h>
  53 #include <sys/pattr.h>
  54 
  55 #define DLSAPLENGTH(macinfo) \
  56         ((macinfo)->gldm_addrlen + ABS((macinfo)->gldm_saplen))
  57 
  58 #ifdef GLD_DEBUG
  59 extern int gld_debug;
  60 #endif
  61 
  62 extern void gld_bitrevcopy(caddr_t src, caddr_t target, size_t n);
  63 extern char *gld_macaddr_sprintf(char *, unsigned char *, int);
  64 extern gld_vlan_t *gld_find_vlan(gld_mac_info_t *, uint32_t);
  65 extern uint32_t gld_global_options;
  66 
  67 static struct   llc_snap_hdr llc_snap_def = {
  68         LSAP_SNAP,              /* DLSAP 0xaa */
  69         LSAP_SNAP,              /* SLSAP 0xaa */
  70         CNTL_LLC_UI,            /* Control 0x03 */
  71         0x00, 0x00, 0x00,       /* Org[3] */
  72         0x00                    /* Type */
  73 };
  74 
  75 #define ISETHERTYPE(snaphdr) \
  76         (snaphdr->d_lsap == LSAP_SNAP && \
  77         snaphdr->s_lsap == LSAP_SNAP && \
  78         snaphdr->control == CNTL_LLC_UI && \
  79         snaphdr->org[0] == 0 && \
  80         snaphdr->org[1] == 0 && \
  81         snaphdr->org[2] == 0)
  82 
  83 /* ======== */
  84 /* Ethernet */
  85 /* ======== */
  86 
  87 static mac_addr_t ether_broadcast = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  88 
  89 void
  90 gld_init_ether(gld_mac_info_t *macinfo)
  91 {
  92         struct gldkstats *sp =
  93             ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->kstatp->ks_data;
  94 
  95         /* Assumptions we make for this medium */
  96         ASSERT(macinfo->gldm_type == DL_ETHER);
  97         ASSERT(macinfo->gldm_addrlen == 6);
  98         ASSERT(macinfo->gldm_saplen == -2);
  99 #ifndef lint
 100         ASSERT(sizeof (struct ether_header) == 14);
 101         ASSERT(sizeof (mac_addr_t) == 6);
 102 #endif
 103 
 104         kstat_named_init(&sp->glds_frame, "align_errors", KSTAT_DATA_ULONG);
 105         kstat_named_init(&sp->glds_crc, "fcs_errors", KSTAT_DATA_ULONG);
 106         kstat_named_init(&sp->glds_collisions, "collisions", KSTAT_DATA_ULONG);
 107         kstat_named_init(&sp->glds_nocarrier, "carrier_errors",
 108             KSTAT_DATA_ULONG);
 109         kstat_named_init(&sp->glds_defer, "defer_xmts", KSTAT_DATA_ULONG);
 110         kstat_named_init(&sp->glds_xmtlatecoll, "tx_late_collisions",
 111                                         KSTAT_DATA_ULONG);
 112         kstat_named_init(&sp->glds_short, "runt_errors", KSTAT_DATA_ULONG);
 113         kstat_named_init(&sp->glds_excoll, "ex_collisions", KSTAT_DATA_ULONG);
 114 
 115         /*
 116          * only initialize the new statistics if the driver
 117          * knows about them.
 118          */
 119         if (macinfo->gldm_driver_version != GLD_VERSION_200)
 120                 return;
 121 
 122         kstat_named_init(&sp->glds_dot3_first_coll,
 123             "first_collisions", KSTAT_DATA_UINT32);
 124         kstat_named_init(&sp->glds_dot3_multi_coll,
 125             "multi_collisions", KSTAT_DATA_UINT32);
 126         kstat_named_init(&sp->glds_dot3_sqe_error,
 127             "sqe_errors", KSTAT_DATA_UINT32);
 128         kstat_named_init(&sp->glds_dot3_mac_xmt_error,
 129             "macxmt_errors", KSTAT_DATA_UINT32);
 130         kstat_named_init(&sp->glds_dot3_mac_rcv_error,
 131             "macrcv_errors", KSTAT_DATA_UINT32);
 132         kstat_named_init(&sp->glds_dot3_frame_too_long,
 133             "toolong_errors", KSTAT_DATA_UINT32);
 134         kstat_named_init(&sp->glds_duplex, "duplex", KSTAT_DATA_CHAR);
 135 }
 136 
 137 /*ARGSUSED*/
 138 void
 139 gld_uninit_ether(gld_mac_info_t *macinfo)
 140 {
 141 }
 142 
 143 int
 144 gld_interpret_ether(gld_mac_info_t *macinfo, mblk_t *mp, pktinfo_t *pktinfo,
 145     packet_flag_t flags)
 146 {
 147         struct ether_header *mh;
 148         gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
 149         struct llc_snap_hdr *snaphdr;
 150         mblk_t *pmp = NULL, *savemp = mp;
 151         unsigned short typelen;
 152         int ret = 0;
 153 
 154         /*
 155          * Quickly handle receive fastpath for IPQ hack.
 156          */
 157         if (flags == GLD_RXQUICK) {
 158                 pktinfo->pktLen = msgdsize(mp);
 159                 /*
 160                  * Check whether the header is contiguous, which
 161                  * also implicitly makes sure the packet is big enough.
 162                  */
 163                 if (MBLKL(mp) < sizeof (struct ether_header))
 164                         return (-1);
 165                 mh = (struct ether_header *)mp->b_rptr;
 166                 pktinfo->ethertype = REF_NET_USHORT(mh->ether_type);
 167                 pktinfo->isForMe = mac_eq(&mh->ether_dhost,
 168                     mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
 169                 pktinfo->macLen = sizeof (struct ether_header);
 170 
 171                 return (0);
 172         }
 173 
 174         bzero((void *)pktinfo, sizeof (*pktinfo));
 175 
 176         pktinfo->pktLen = msgdsize(mp);
 177 
 178         /* make sure packet has at least a whole mac header */
 179         if (pktinfo->pktLen < sizeof (struct ether_header))
 180                 return (-1);
 181 
 182         /* make sure the mac header falls into contiguous memory */
 183         if (MBLKL(mp) < sizeof (struct ether_header)) {
 184                 if ((pmp = msgpullup(mp, -1)) == NULL) {
 185 #ifdef GLD_DEBUG
 186                         if (gld_debug & GLDERRS)
 187                                 cmn_err(CE_WARN,
 188                                     "GLD: interpret_ether cannot msgpullup");
 189 #endif
 190                         return (-1);
 191                 }
 192                 mp = pmp;       /* this mblk contains the whole mac header */
 193         }
 194 
 195         mh = (struct ether_header *)mp->b_rptr;
 196 
 197         /* Check to see if the mac is a broadcast or multicast address. */
 198         if (mac_eq(&mh->ether_dhost, ether_broadcast, macinfo->gldm_addrlen))
 199                 pktinfo->isBroadcast = 1;
 200         else if (mh->ether_dhost.ether_addr_octet[0] & 1)
 201                 pktinfo->isMulticast = 1;
 202 
 203         typelen = REF_NET_USHORT(mh->ether_type);
 204         /*
 205          * If the hardware is capable of VLAN tag insertion
 206          * strip out the VLAN tag info. Knowing hardware is
 207          * capable of VLAN can be established by the presance
 208          * of non null 'macinfo->gldm_send_tagged'.
 209          */
 210         if (flags == GLD_TX) {
 211                 if ((typelen == ETHERTYPE_VLAN) &&
 212                     (macinfo->gldm_send_tagged != NULL)) {
 213                         struct ether_vlan_header *evhp;
 214                         uint16_t tci;
 215 
 216                         if ((MBLKL(mp) < sizeof (struct ether_vlan_header)) &&
 217                             (pullupmsg(mp, sizeof (struct ether_vlan_header))
 218                             == 0)) {
 219                                 ret = -1;
 220                                 goto out;
 221                         }
 222                         evhp = (struct ether_vlan_header *)mp->b_rptr;
 223                         tci = REF_NET_USHORT(evhp->ether_tci);
 224 
 225                         /*
 226                          * We don't allow the VID and priority are both zero.
 227                          */
 228                         if ((GLD_VTAG_PRI((int32_t)tci) == 0 &&
 229                             GLD_VTAG_VID((int32_t)tci) == VLAN_VID_NONE) ||
 230                             (GLD_VTAG_CFI((uint32_t)tci)) != VLAN_CFI_ETHER) {
 231                                 ret = -1;
 232                                 goto out;
 233                         }
 234 
 235                         /*
 236                          * Remember the VTAG info in order to reinsert it,
 237                          * Then strip the tag. This is required because some
 238                          * drivers do not allow the size of message (passed
 239                          * by the gldm_send_tagged() function) to be greater
 240                          * than ETHERMAX.
 241                          */
 242                         GLD_SAVE_MBLK_VTAG(savemp, GLD_TCI2VTAG(tci));
 243                         ovbcopy(mp->b_rptr, mp->b_rptr + VTAG_SIZE,
 244                             2 * ETHERADDRL);
 245                         mp->b_rptr += VTAG_SIZE;
 246                 }
 247                 goto out;       /* Got all info we need for xmit case */
 248         }
 249 
 250         ASSERT(GLDM_LOCK_HELD(macinfo));
 251 
 252         /*
 253          * Deal with the mac header
 254          */
 255 
 256         mac_copy(&mh->ether_dhost, pktinfo->dhost, macinfo->gldm_addrlen);
 257         mac_copy(&mh->ether_shost, pktinfo->shost, macinfo->gldm_addrlen);
 258 
 259         pktinfo->isLooped = mac_eq(pktinfo->shost,
 260             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
 261         pktinfo->isForMe = mac_eq(pktinfo->dhost,
 262             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
 263 
 264         pktinfo->macLen = sizeof (struct ether_header);
 265 
 266         if (typelen > ETHERMTU) {
 267                 pktinfo->ethertype = typelen; /* use type interpretation */
 268                 goto out;
 269         }
 270 
 271         /*
 272          * Packet is 802.3 so the ether type/length field
 273          * specifies the number of bytes that should be present
 274          * in the data field.  Additional bytes are padding, and
 275          * should be removed
 276          */
 277         {
 278         int delta = pktinfo->pktLen -
 279             (sizeof (struct ether_header) + typelen);
 280 
 281         if (delta > 0 && adjmsg(mp, -delta))
 282                 pktinfo->pktLen -= delta;
 283         }
 284 
 285         /*
 286          * Before trying to look beyond the MAC header, make sure the LLC
 287          * header exists, and that both it and any SNAP header are contiguous.
 288          */
 289         if (pktinfo->pktLen < pktinfo->macLen + LLC_HDR1_LEN)
 290                 goto out;       /* LLC hdr should have been there! */
 291 
 292         pktinfo->isLLC = 1;
 293 
 294         if (gld_global_options & GLD_OPT_NO_ETHRXSNAP ||
 295             pktinfo->pktLen <  pktinfo->macLen + LLC_SNAP_HDR_LEN)
 296                 goto out;
 297 
 298         if (MBLKL(mp) < sizeof (struct ether_header) + LLC_SNAP_HDR_LEN &&
 299             MBLKL(mp) < pktinfo->pktLen) {
 300                 /*
 301                  * we don't have the entire packet within the first mblk (and
 302                  * therefore we didn't do the msgpullup above), AND the first
 303                  * mblk may not contain all the data we need to look at.
 304                  */
 305                 ASSERT(pmp == NULL);    /* couldn't have done msgpullup above */
 306                 if ((pmp = msgpullup(mp, -1)) == NULL) {
 307 #ifdef GLD_DEBUG
 308                         if (gld_debug & GLDERRS)
 309                                 cmn_err(CE_WARN,
 310                                     "GLD: interpret_ether cannot msgpullup2");
 311 #endif
 312                         goto out;       /* can't interpret this pkt further */
 313                 }
 314                 mp = pmp;       /* this mblk should contain everything needed */
 315         }
 316 
 317         /*
 318          * Check SAP/SNAP information for EtherType.
 319          */
 320 
 321         snaphdr = (struct llc_snap_hdr *)(mp->b_rptr + pktinfo->macLen);
 322         if (ISETHERTYPE(snaphdr)) {
 323                 pktinfo->ethertype = REF_NET_USHORT(snaphdr->type);
 324                 pktinfo->hdrLen = LLC_SNAP_HDR_LEN;
 325         }
 326 out:
 327         if (pmp != NULL)
 328                 freemsg(pmp);
 329 
 330         return (ret);
 331 }
 332 
 333 mblk_t *
 334 gld_unitdata_ether(gld_t *gld, mblk_t *mp)
 335 {
 336         gld_mac_info_t *macinfo = gld->gld_mac_info;
 337         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
 338         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
 339         mac_addr_t dhost;
 340         unsigned short typelen;
 341         mblk_t *nmp;
 342         struct ether_header *mh;
 343         int hdrlen;
 344         uint32_t vptag;
 345         gld_vlan_t *gld_vlan;
 346 
 347         ASSERT(macinfo);
 348 
 349         /* extract needed info from the mblk before we maybe reuse it */
 350         mac_copy(gldp->glda_addr, dhost, macinfo->gldm_addrlen);
 351 
 352         /* look in the unitdata request for a sap, else use bound one */
 353         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
 354             REF_HOST_USHORT(gldp->glda_sap) != 0)
 355                 typelen = REF_HOST_USHORT(gldp->glda_sap);
 356         else
 357                 typelen = gld->gld_sap;
 358 
 359         /*
 360          * We take values less than or equal to ETHERMTU to mean that the
 361          * packet should not have an encoded EtherType and so we use the
 362          * IEEE 802.3 length interpretation of the type/length field.
 363          */
 364         if (typelen <= ETHERMTU)
 365                 typelen = msgdsize(mp);
 366 
 367         hdrlen = sizeof (struct ether_header);
 368 
 369         /*
 370          * Check to see if VLAN is enabled on this stream
 371          * if so then make the header bigger to hold a clone
 372          * vlan tag.
 373          */
 374         gld_vlan = (gld_vlan_t *)gld->gld_vlan;
 375         if (gld_vlan && (gld_vlan->gldv_id != VLAN_VID_NONE)) {
 376                 hdrlen += VTAG_SIZE;
 377                 vptag = gld_vlan->gldv_ptag;
 378         }
 379 
 380         /* need a buffer big enough for the headers */
 381         nmp = mp->b_cont;    /* where the packet payload M_DATA is */
 382         if (DB_REF(nmp) == 1 && MBLKHEAD(nmp) >= hdrlen) {
 383                 /* it fits at the beginning of the first M_DATA block */
 384                 freeb(mp);      /* don't need the M_PROTO anymore */
 385         } else if (DB_REF(mp) == 1 && MBLKSIZE(mp) >= hdrlen) {
 386                 /* we can reuse the dl_unitdata_req M_PROTO mblk */
 387                 nmp = mp;
 388                 DB_TYPE(nmp) = M_DATA;
 389                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 390         } else {
 391                 /* we need to allocate one */
 392                 if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
 393                         return (NULL);
 394                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 395                 linkb(nmp, mp->b_cont);
 396                 freeb(mp);
 397         }
 398 
 399         /* Got the space, now copy in the header components */
 400 
 401         nmp->b_rptr -= sizeof (typelen);
 402         SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, typelen);
 403         if (hdrlen > sizeof (struct ether_header)) {
 404                 nmp->b_rptr -= sizeof (uint16_t);
 405                 SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, vptag);
 406                 vptag >>= 16;
 407                 nmp->b_rptr -= sizeof (uint16_t);
 408                 SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, vptag);
 409         }
 410         nmp->b_rptr -= (ETHERADDRL * 2);
 411         mh = (struct ether_header *)nmp->b_rptr;
 412         mac_copy(dhost, &mh->ether_dhost, macinfo->gldm_addrlen);
 413 
 414         /*
 415          * We access the mac address without the mutex to prevent
 416          * mutex contention (BUG 4211361)
 417          */
 418         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
 419             &mh->ether_shost, macinfo->gldm_addrlen);
 420 
 421         return (nmp);
 422 }
 423 
 424 /*
 425  * Insert the VLAN tag into the packet. The packet now is an Ethernet header
 426  * without VLAN tag information.
 427  */
 428 mblk_t *
 429 gld_insert_vtag_ether(mblk_t *mp, uint32_t vtag)
 430 {
 431         struct ether_vlan_header *evhp;
 432         struct ether_header *ehp;
 433         mblk_t *nmp;
 434 
 435         if (vtag == VLAN_VID_NONE)
 436                 return (mp);
 437 
 438         if (DB_REF(mp) == 1 && MBLKHEAD(mp) >= VTAG_SIZE) {
 439                 /* it fits at the beginning of the message block */
 440                 nmp = mp;
 441                 ovbcopy(nmp->b_rptr, nmp->b_rptr - VTAG_SIZE, 2 * ETHERADDRL);
 442                 nmp->b_rptr -= VTAG_SIZE;
 443                 evhp = (struct ether_vlan_header *)nmp->b_rptr;
 444         } else {
 445                 /* we need to allocate one */
 446                 if ((nmp = allocb(sizeof (struct ether_vlan_header),
 447                     BPRI_MED)) == NULL) {
 448                         return (NULL);
 449                 }
 450                 nmp->b_wptr += sizeof (struct ether_vlan_header);
 451 
 452                 /* transfer the ether_header fields */
 453                 evhp = (struct ether_vlan_header *)nmp->b_rptr;
 454                 ehp = (struct ether_header *)mp->b_rptr;
 455                 mac_copy(&ehp->ether_dhost, &evhp->ether_dhost, ETHERADDRL);
 456                 mac_copy(&ehp->ether_shost, &evhp->ether_shost, ETHERADDRL);
 457                 bcopy(&ehp->ether_type, &evhp->ether_type, sizeof (uint16_t));
 458 
 459                 /* offset the mp of the MAC header length. */
 460                 mp->b_rptr += sizeof (struct ether_header);
 461                 if (MBLKL(mp) == 0) {
 462                         nmp->b_cont = mp->b_cont;
 463                         freeb(mp);
 464                 } else {
 465                         nmp->b_cont = mp;
 466                 }
 467         }
 468 
 469         SET_NET_USHORT(evhp->ether_tci, vtag);
 470         vtag >>= 16;
 471         SET_NET_USHORT(evhp->ether_tpid, vtag);
 472         return (nmp);
 473 }
 474 
 475 mblk_t *
 476 gld_fastpath_ether(gld_t *gld, mblk_t *mp)
 477 {
 478         gld_mac_info_t *macinfo = gld->gld_mac_info;
 479         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_cont->b_rptr;
 480         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
 481         unsigned short typelen;
 482         mblk_t *nmp;
 483         struct ether_header *mh;
 484         int hdrlen;
 485         uint32_t vptag;
 486         gld_vlan_t *gld_vlan;
 487 
 488         ASSERT(macinfo);
 489 
 490         /* look in the unitdata request for a sap, else use bound one */
 491         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
 492             REF_HOST_USHORT(gldp->glda_sap) != 0)
 493                 typelen = REF_HOST_USHORT(gldp->glda_sap);
 494         else
 495                 typelen = gld->gld_sap;
 496 
 497         /*
 498          * We only do fast-path for EtherType encoding because this is the only
 499          * case where the media header will be consistent from packet to packet.
 500          */
 501         if (typelen <= ETHERMTU)
 502                 return (NULL);
 503 
 504         /*
 505          * Initialize the fast path header to include the
 506          * basic source address information and type field.
 507          */
 508         hdrlen = sizeof (struct ether_header);
 509 
 510         /*
 511          * Check to see if VLAN is enabled on this stream
 512          * if so then make the header bigger to hold a clone
 513          * vlan tag.
 514          */
 515         gld_vlan = (gld_vlan_t *)gld->gld_vlan;
 516         if (gld_vlan && (gld_vlan->gldv_id != VLAN_VID_NONE)) {
 517                 hdrlen += VTAG_SIZE;
 518                 vptag = gld_vlan->gldv_ptag;
 519         }
 520 
 521         if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
 522                 return (NULL);
 523 
 524         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 525 
 526         /* Got the space, now copy in the header components */
 527 
 528         nmp->b_rptr -= sizeof (typelen);
 529         SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, typelen);
 530 
 531         /*
 532          * If the header is for a VLAN stream, then add
 533          * in the VLAN tag to the clone header.
 534          */
 535         if (hdrlen > sizeof (struct ether_header)) {
 536                 nmp->b_rptr -= sizeof (uint16_t);
 537                 SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, vptag);
 538                 vptag >>= 16;
 539                 nmp->b_rptr -= sizeof (uint16_t);
 540                 SET_NET_USHORT(*(uint16_t *)nmp->b_rptr, vptag);
 541         }
 542         nmp->b_rptr -= (ETHERADDRL * 2);
 543         mh = (struct ether_header *)nmp->b_rptr;
 544         mac_copy(gldp->glda_addr, &mh->ether_dhost, macinfo->gldm_addrlen);
 545 
 546         GLDM_LOCK(macinfo, RW_WRITER);
 547         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
 548             &mh->ether_shost, macinfo->gldm_addrlen);
 549         GLDM_UNLOCK(macinfo);
 550 
 551         return (nmp);
 552 }
 553 
 554 /* == */
 555 /* IB */
 556 /* == */
 557 
 558 void
 559 gld_init_ib(gld_mac_info_t *macinfo)
 560 {
 561         /*
 562          * Currently, the generic stats maintained by GLD is
 563          * sufficient for IPoIB.
 564          */
 565 
 566         /* Assumptions we make for this medium */
 567         ASSERT(macinfo->gldm_type == DL_IB);
 568         ASSERT(macinfo->gldm_addrlen == IPOIB_ADDRL);
 569         ASSERT(macinfo->gldm_saplen == -2);
 570 }
 571 
 572 /* ARGSUSED */
 573 void
 574 gld_uninit_ib(gld_mac_info_t *macinfo)
 575 {
 576 }
 577 
 578 /*
 579  * The packet format sent to the driver is:
 580  * IPOIB_ADDRL bytes dest addr :: 2b sap :: 2b 0s :: data
 581  * The packet format received from the driver is:
 582  * IPOIB_GRH_SIZE bytes pseudo GRH :: 2b sap :: 2b 0s :: data.
 583  */
 584 int
 585 gld_interpret_ib(gld_mac_info_t *macinfo, mblk_t *mp, pktinfo_t *pktinfo,
 586     packet_flag_t flags)
 587 {
 588         ipoib_pgrh_t *grh;
 589         ipoib_ptxhdr_t *gldp;
 590         mblk_t *pmp = NULL;
 591         gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
 592 
 593         /*
 594          * Quickly handle receive fastpath for IPQ hack.
 595          */
 596         if (flags == GLD_RXQUICK) {
 597                 pktinfo->pktLen = msgdsize(mp) - IPOIB_GRH_SIZE;
 598 
 599                 /*
 600                  * Check whether the header is contiguous, which
 601                  * also implicitly makes sure the packet is big enough.
 602                  */
 603                 if (MBLKL(mp) < (IPOIB_GRH_SIZE + IPOIB_HDRSIZE))
 604                         return (-1);
 605 
 606                 /*
 607                  * Almost all times, unicast will not have
 608                  * a valid pgrh; quickly identify and ask for
 609                  * IPQ hack optimization only in that case.
 610                  */
 611                 grh = (ipoib_pgrh_t *)mp->b_rptr;
 612                 if (grh->ipoib_vertcflow == 0) {
 613                         struct ipoib_header *ihp = (struct ipoib_header *)
 614                             (mp->b_rptr + IPOIB_GRH_SIZE);
 615 
 616                         pktinfo->isForMe = 1;
 617                         pktinfo->ethertype = REF_NET_USHORT(ihp->ipoib_type);
 618                         pktinfo->macLen = IPOIB_GRH_SIZE + IPOIB_HDRSIZE;
 619                         return (0);
 620                 } else {
 621                         return (-1);
 622                 }
 623         }
 624 
 625         /*
 626          * Handle the GLD_TX, GLD_RX, GLD_RXLOOP cases now.
 627          */
 628         ASSERT(flags != GLD_RXQUICK);
 629         bzero((void *)pktinfo, sizeof (*pktinfo));
 630 
 631         if (flags != GLD_RX) {
 632                 /*
 633                  * GLD_TX and GLD_RXLOOP cases.
 634                  */
 635                 gldp = (ipoib_ptxhdr_t *)mp->b_rptr;
 636                 pktinfo->pktLen = msgdsize(mp);
 637 
 638                 /* make sure packet has at least a pseudo header */
 639                 if (pktinfo->pktLen < sizeof (ipoib_ptxhdr_t))
 640                         return (-1);
 641 
 642                 /* make sure the mac header falls into contiguous memory */
 643                 if (MBLKL(mp) < sizeof (ipoib_ptxhdr_t)) {
 644                         if ((pmp = msgpullup(mp, -1)) == NULL) {
 645 #ifdef GLD_DEBUG
 646                                 if (gld_debug & GLDERRS)
 647                                         cmn_err(CE_WARN,
 648                                             "GLD: interpret_ib "
 649                                             "cannot msgpullup");
 650 #endif
 651                                 return (-1);
 652                         }
 653                         /* this mblk contains the whole mac header */
 654                         mp = pmp;
 655                 }
 656 
 657                 /*
 658                  * Check if mac is broadcast or multicast address; all these
 659                  * types of address have the top 4 bytes as 0x00FFFFFF.
 660                  */
 661                 if (mac_eq(&gldp->ipoib_dest, macinfo->gldm_broadcast_addr,
 662                     sizeof (uint32_t))) {
 663                         if (mac_eq(&gldp->ipoib_dest,
 664                             macinfo->gldm_broadcast_addr, IPOIB_ADDRL))
 665                                 pktinfo->isBroadcast = 1;
 666                         else
 667                                 pktinfo->isMulticast = 1;
 668                 }
 669 
 670                 /*
 671                  * Only count bytes we will be sending over the wire
 672                  * or looping back.
 673                  */
 674                 pktinfo->pktLen -= IPOIB_ADDRL;
 675                 if (flags == GLD_TX)
 676                         goto out;       /* Got all info we need for xmit case */
 677 
 678                 /*
 679                  * Loopback case: this is a dup'ed message.
 680                  */
 681                 mp->b_rptr += IPOIB_ADDRL;
 682                 mac_copy(&gldp->ipoib_dest, pktinfo->dhost, IPOIB_ADDRL);
 683                 mac_copy(mac_pvt->curr_macaddr, pktinfo->shost, IPOIB_ADDRL);
 684         } else {
 685                 /*
 686                  * GLD_RX case; process packet sent from driver.
 687                  */
 688                 ipoib_mac_t *mact, *tact;
 689                 ib_qpn_t dqpn;
 690 
 691                 pktinfo->pktLen = msgdsize(mp);
 692                 /* make sure packet has at least pgrh and mac header */
 693                 if (pktinfo->pktLen < (IPOIB_GRH_SIZE + IPOIB_HDRSIZE))
 694                         return (-1);
 695 
 696                 /* make sure the header falls into contiguous memory */
 697                 if (MBLKL(mp) < (IPOIB_GRH_SIZE + IPOIB_HDRSIZE)) {
 698                         if ((pmp = msgpullup(mp, -1)) == NULL) {
 699 #ifdef GLD_DEBUG
 700                                 if (gld_debug & GLDERRS)
 701                                         cmn_err(CE_WARN,
 702                                             "GLD: interpret_ib "
 703                                             "cannot msgpullup2");
 704 #endif
 705                                 return (-1);
 706                         }
 707                         /* this mblk contains the whole mac header */
 708                         mp = pmp;
 709                 }
 710 
 711                 grh = (ipoib_pgrh_t *)mp->b_rptr;
 712                 mp->b_rptr += IPOIB_GRH_SIZE;
 713                 pktinfo->pktLen -= IPOIB_GRH_SIZE;
 714                 if (grh->ipoib_vertcflow) {
 715                         /*
 716                          * First, copy source address from grh.
 717                          */
 718                         mact = (ipoib_mac_t *)pktinfo->shost;
 719                         mac_copy(&grh->ipoib_sqpn, &mact->ipoib_qpn,
 720                             IPOIB_ADDRL);
 721 
 722                         /*
 723                          * Then copy destination address from grh;
 724                          * first, the 16 bytes of GID.
 725                          */
 726                         mact = (ipoib_mac_t *)pktinfo->dhost;
 727                         mac_copy(&grh->ipoib_dgid_pref,
 728                             &mact->ipoib_gidpref, IPOIB_ADDRL -
 729                             sizeof (mact->ipoib_qpn));
 730                         tact = (ipoib_mac_t *)mac_pvt->curr_macaddr;
 731 
 732                         /* Is this a multicast address */
 733                         if (*(uchar_t *)(grh->ipoib_dgid_pref) == 0xFF) {
 734                                 /*
 735                                  * Only check for hardware looping in
 736                                  * multicast case. It is assumed higher
 737                                  * layer code (IP) will stop unicast loops;
 738                                  * ie will prevent a transmit to self.
 739                                  */
 740                                 if (bcmp(&grh->ipoib_sqpn, tact,
 741                                     IPOIB_ADDRL) == 0)
 742                                         pktinfo->isLooped = 1;
 743 
 744                                 tact = (ipoib_mac_t *)macinfo->
 745                                     gldm_broadcast_addr;
 746                                 if (mac_eq(tact->ipoib_gidpref,
 747                                     grh->ipoib_dgid_pref,
 748                                     IPOIB_ADDRL - sizeof (tact->ipoib_qpn)))
 749                                         pktinfo->isBroadcast = 1;
 750                                 else
 751                                         pktinfo->isMulticast = 1;
 752                                 /*
 753                                  * Now copy the 4 bytes QPN part of the
 754                                  * destination address.
 755                                  */
 756                                 dqpn = htonl(IB_MC_QPN);
 757                                 mac_copy(&dqpn, &mact->ipoib_qpn,
 758                                     sizeof (mact->ipoib_qpn));
 759                         } else {
 760                                 /*
 761                                  * Now copy the 4 bytes QPN part of the
 762                                  * destination address.
 763                                  */
 764                                 mac_copy(&tact->ipoib_qpn, &mact->ipoib_qpn,
 765                                     sizeof (mact->ipoib_qpn));
 766                                 /*
 767                                  * Any unicast packets received on IBA are
 768                                  * for the node.
 769                                  */
 770                                 pktinfo->isForMe = 1;
 771                         }
 772                 } else {
 773                         /*
 774                          * It can not be a IBA multicast packet.
 775                          * Must have been unicast to us. We do not
 776                          * have shost information, which is used in
 777                          * gld_addudind(); IP/ARP does not care.
 778                          */
 779                         pktinfo->nosource = 1;
 780                         mac_copy(mac_pvt->curr_macaddr, pktinfo->dhost,
 781                             IPOIB_ADDRL);
 782                         /*
 783                          * Any unicast packets received on IBA are
 784                          * for the node.
 785                          */
 786                         pktinfo->isForMe = 1;
 787                 }
 788         }
 789 
 790         ASSERT((flags == GLD_RX) || (flags == GLD_RXLOOP));
 791         ASSERT(GLDM_LOCK_HELD(macinfo));
 792         pktinfo->ethertype = REF_NET_USHORT(((ipoib_hdr_t *)
 793             (mp->b_rptr))->ipoib_type);
 794         pktinfo->macLen = IPOIB_HDRSIZE;
 795 
 796 out:
 797         if (pmp != NULL)
 798                 freemsg(pmp);
 799 
 800         return (0);
 801 }
 802 
 803 /*
 804  * The packet format sent to the driver is: 2b sap :: 2b 0s :: data
 805  */
 806 void
 807 gld_interpret_mdt_ib(gld_mac_info_t *macinfo, mblk_t *mp, pdescinfo_t *pinfo,
 808     pktinfo_t *pktinfo, mdt_packet_flag_t flags)
 809 {
 810         gld_mac_pvt_t *mac_pvt;
 811         multidata_t *dlmdp;
 812         pattrinfo_t attr_info = { PATTR_DSTADDRSAP, };
 813         pattr_t *patr;
 814         ipoib_ptxhdr_t *dlap = NULL;
 815 
 816         /*
 817          * Per packet formatting.
 818          */
 819         if (flags == GLD_MDT_TXPKT) {
 820                 ipoib_hdr_t *hptr;
 821                 uint_t seg;
 822 
 823                 if (PDESC_HDRL(pinfo) == 0)
 824                         return;
 825 
 826                 /*
 827                  * Update packet's link header.
 828                  */
 829                 pinfo->hdr_rptr -= IPOIB_HDRSIZE;
 830                 hptr = (ipoib_hdr_t *)pinfo->hdr_rptr;
 831                 hptr->ipoib_mbz = htons(0);
 832                 hptr->ipoib_type = pktinfo->ethertype;
 833 
 834                 /*
 835                  * Total #bytes that will be put on wire.
 836                  */
 837                 pktinfo->pktLen = PDESC_HDRL(pinfo);
 838                 for (seg = 0; seg < pinfo->pld_cnt; seg++)
 839                         pktinfo->pktLen += PDESC_PLDL(pinfo, seg);
 840 
 841                 return;
 842         }
 843 
 844         /*
 845          * The following two cases of GLD_MDT_TX and GLD_MDT_RXLOOP are per
 846          * MDT message processing.
 847          */
 848         dlmdp = mmd_getmultidata(mp);
 849         patr = mmd_getpattr(dlmdp, NULL, &attr_info);
 850         ASSERT(patr != NULL);
 851         ASSERT(macinfo->gldm_saplen == -2);
 852         if (patr != NULL)
 853                 dlap = (ipoib_ptxhdr_t *)((pattr_addr_t *)attr_info.buf)->addr;
 854 
 855         if (flags == GLD_MDT_TX) {
 856                 bzero((void *)pktinfo, sizeof (*pktinfo));
 857                 if (dlap == NULL)
 858                         return;
 859 
 860                 /*
 861                  * Check if mac is broadcast or multicast address; all these
 862                  * types of address have the top 4 bytes as 0x00FFFFFF.
 863                  */
 864                 if (mac_eq(dlap, macinfo->gldm_broadcast_addr,
 865                     sizeof (uint32_t))) {
 866                         if (mac_eq(dlap, macinfo->gldm_broadcast_addr,
 867                             IPOIB_ADDRL))
 868                                 pktinfo->isBroadcast = 1;
 869                         else
 870                                 pktinfo->isMulticast = 1;
 871                 }
 872                 pktinfo->ethertype = REF_NET_USHORT(dlap->
 873                     ipoib_rhdr.ipoib_type);
 874         } else {
 875                 ASSERT(flags == GLD_MDT_RXLOOP);
 876                 pktinfo->macLen = IPOIB_HDRSIZE;
 877                 mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
 878                 mac_copy(mac_pvt->curr_macaddr, pktinfo->shost, IPOIB_ADDRL);
 879                 if (dlap == NULL)
 880                         return;
 881                 mac_copy(&dlap->ipoib_dest, pktinfo->dhost, IPOIB_ADDRL);
 882         }
 883 }
 884 
 885 mblk_t *
 886 gld_unitdata_ib(gld_t *gld, mblk_t *mp)
 887 {
 888         gld_mac_info_t *macinfo = gld->gld_mac_info;
 889         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
 890         ipoib_ptxhdr_t *gldp = IPOIBDLSAP(dlp, dlp->dl_dest_addr_offset);
 891         ipoib_mac_t dhost;
 892         unsigned short type;
 893         mblk_t *nmp;
 894         int hdrlen;
 895 
 896         ASSERT(macinfo != NULL);
 897 
 898         /* extract needed info from the mblk before we maybe reuse it */
 899         mac_copy(&gldp->ipoib_dest, &dhost, IPOIB_ADDRL);
 900 
 901         /* look in the unitdata request for a sap, else use bound one */
 902         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
 903             REF_HOST_USHORT(gldp->ipoib_rhdr.ipoib_type) != 0)
 904                 type = REF_HOST_USHORT(gldp->ipoib_rhdr.ipoib_type);
 905         else
 906                 type = gld->gld_sap;
 907 
 908         hdrlen = sizeof (ipoib_ptxhdr_t);
 909 
 910         /* need a buffer big enough for the headers */
 911         nmp = mp->b_cont;    /* where the packet payload M_DATA is */
 912         if (DB_REF(nmp) == 1 && MBLKHEAD(nmp) >= hdrlen) {
 913                 /* it fits at the beginning of the first M_DATA block */
 914                 freeb(mp);      /* don't need the M_PROTO anymore */
 915         } else if (DB_REF(mp) == 1 && MBLKSIZE(mp) >= hdrlen) {
 916                 /* we can reuse the dl_unitdata_req M_PROTO mblk */
 917                 nmp = mp;
 918                 DB_TYPE(nmp) = M_DATA;
 919                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 920         } else {
 921                 /* we need to allocate one */
 922                 if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
 923                         return (NULL);
 924                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 925                 linkb(nmp, mp->b_cont);
 926                 freeb(mp);
 927         }
 928 
 929         /* Got the space, now copy in the header components */
 930 
 931         nmp->b_rptr -= sizeof (ipoib_ptxhdr_t);
 932         gldp = (ipoib_ptxhdr_t *)nmp->b_rptr;
 933         SET_NET_USHORT(gldp->ipoib_rhdr.ipoib_type, type);
 934         gldp->ipoib_rhdr.ipoib_mbz = 0;
 935         mac_copy(&dhost, &gldp->ipoib_dest, IPOIB_ADDRL);
 936 
 937         return (nmp);
 938 }
 939 
 940 mblk_t *
 941 gld_fastpath_ib(gld_t *gld, mblk_t *mp)
 942 {
 943         gld_mac_info_t *macinfo = gld->gld_mac_info;
 944         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_cont->b_rptr;
 945         ipoib_ptxhdr_t *gldp = IPOIBDLSAP(dlp, dlp->dl_dest_addr_offset);
 946         unsigned short type;
 947         mblk_t *nmp;
 948         ipoib_ptxhdr_t *tgldp;
 949         int hdrlen;
 950 
 951         ASSERT(macinfo != NULL);
 952 
 953         /* look in the unitdata request for a sap, else use bound one */
 954         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
 955             REF_HOST_USHORT(gldp->ipoib_rhdr.ipoib_type) != 0)
 956                 type = REF_HOST_USHORT(gldp->ipoib_rhdr.ipoib_type);
 957         else
 958                 type = gld->gld_sap;
 959 
 960         hdrlen = sizeof (ipoib_ptxhdr_t);
 961 
 962         if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
 963                 return (NULL);
 964 
 965         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
 966 
 967         /* Got the space, now copy in the header components */
 968 
 969         nmp->b_rptr -= sizeof (ipoib_ptxhdr_t);
 970         tgldp = (ipoib_ptxhdr_t *)nmp->b_rptr;
 971         tgldp->ipoib_rhdr.ipoib_type = htons(type);
 972         tgldp->ipoib_rhdr.ipoib_mbz = 0;
 973         mac_copy(&gldp->ipoib_dest, &tgldp->ipoib_dest, IPOIB_ADDRL);
 974 
 975         return (nmp);
 976 }
 977 
 978 /* ==== */
 979 /* FDDI */
 980 /* ==== */
 981 
 982 void
 983 gld_init_fddi(gld_mac_info_t *macinfo)
 984 {
 985         struct gldkstats *sp =
 986             ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->kstatp->ks_data;
 987 
 988         /* Assumptions we make for this medium */
 989         ASSERT(macinfo->gldm_type == DL_FDDI);
 990         ASSERT(macinfo->gldm_addrlen == 6);
 991         ASSERT(macinfo->gldm_saplen == -2);
 992 #ifndef lint
 993         ASSERT(sizeof (struct fddi_mac_frm) == 13);
 994         ASSERT(sizeof (mac_addr_t) == 6);
 995 #endif
 996 
 997         /* Wire address format is bit reversed from canonical format */
 998         macinfo->gldm_options |= GLDOPT_CANONICAL_ADDR;
 999 
1000         kstat_named_init(&sp->glds_fddi_mac_error,
1001             "mac_errors", KSTAT_DATA_UINT32);
1002         kstat_named_init(&sp->glds_fddi_mac_lost,
1003             "mac_lost_errors", KSTAT_DATA_UINT32);
1004         kstat_named_init(&sp->glds_fddi_mac_token,
1005             "mac_tokens", KSTAT_DATA_UINT32);
1006         kstat_named_init(&sp->glds_fddi_mac_tvx_expired,
1007             "mac_tvx_expired", KSTAT_DATA_UINT32);
1008         kstat_named_init(&sp->glds_fddi_mac_late,
1009             "mac_late", KSTAT_DATA_UINT32);
1010         kstat_named_init(&sp->glds_fddi_mac_ring_op,
1011             "mac_ring_ops", KSTAT_DATA_UINT32);
1012 }
1013 
1014 /*ARGSUSED*/
1015 void
1016 gld_uninit_fddi(gld_mac_info_t *macinfo)
1017 {
1018 }
1019 
1020 int
1021 gld_interpret_fddi(gld_mac_info_t *macinfo, mblk_t *mp, pktinfo_t *pktinfo,
1022     packet_flag_t flags)
1023 {
1024         struct fddi_mac_frm *mh;
1025         gld_mac_pvt_t *mac_pvt;
1026         struct llc_snap_hdr *snaphdr;
1027         mblk_t *pmp = NULL;
1028 
1029         /*
1030          * Quickly handle receive fastpath; FDDI does not support IPQ hack.
1031          */
1032         if (flags == GLD_RXQUICK) {
1033                 pktinfo->pktLen = msgdsize(mp);
1034                 return (-1);
1035         }
1036 
1037         bzero((void *)pktinfo, sizeof (*pktinfo));
1038 
1039         pktinfo->pktLen = msgdsize(mp);
1040 
1041         /* make sure packet has at least a whole mac header */
1042         if (pktinfo->pktLen < sizeof (struct fddi_mac_frm))
1043                 return (-1);
1044 
1045         /* make sure the mac header falls into contiguous memory */
1046         if (MBLKL(mp) < sizeof (struct fddi_mac_frm)) {
1047                 if ((pmp = msgpullup(mp, -1)) == NULL) {
1048 #ifdef GLD_DEBUG
1049                         if (gld_debug & GLDERRS)
1050                                 cmn_err(CE_WARN,
1051                                     "GLD: interpret_fddi cannot msgpullup");
1052 #endif
1053                         return (-1);
1054                 }
1055                 mp = pmp;       /* this mblk contains the whole mac header */
1056         }
1057 
1058         mh = (struct fddi_mac_frm *)mp->b_rptr;
1059 
1060         /* Check to see if the mac is a broadcast or multicast address. */
1061         /* NB we are still in wire format (non canonical) */
1062         /* mac_eq works because ether_broadcast is the same either way */
1063         if (mac_eq(mh->fddi_dhost, ether_broadcast, macinfo->gldm_addrlen))
1064                 pktinfo->isBroadcast = 1;
1065         else if (mh->fddi_dhost[0] & 0x80)
1066                 pktinfo->isMulticast = 1;
1067 
1068         if (flags == GLD_TX)
1069                 goto out;       /* Got all info we need for xmit case */
1070 
1071         ASSERT(GLDM_LOCK_HELD(macinfo));
1072 
1073         /*
1074          * Deal with the mac header
1075          */
1076 
1077         cmac_copy(mh->fddi_dhost, pktinfo->dhost,
1078             macinfo->gldm_addrlen, macinfo);
1079         cmac_copy(mh->fddi_shost, pktinfo->shost,
1080             macinfo->gldm_addrlen, macinfo);
1081 
1082         mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
1083         pktinfo->isLooped = mac_eq(pktinfo->shost,
1084             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
1085         pktinfo->isForMe = mac_eq(pktinfo->dhost,
1086             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
1087 
1088         pktinfo->macLen = sizeof (struct fddi_mac_frm);
1089 
1090         /*
1091          * Before trying to look beyond the MAC header, make sure the LLC
1092          * header exists, and that both it and any SNAP header are contiguous.
1093          */
1094         if (MBLKL(mp) < sizeof (struct fddi_mac_frm) + LLC_SNAP_HDR_LEN &&
1095             MBLKL(mp) < pktinfo->pktLen) {
1096                 /*
1097                  * we don't have the entire packet within the first mblk (and
1098                  * therefore we didn't do the msgpullup above), AND the first
1099                  * mblk may not contain all the data we need to look at.
1100                  */
1101                 ASSERT(pmp == NULL);    /* couldn't have done msgpullup above */
1102                 if ((pmp = msgpullup(mp, -1)) == NULL) {
1103 #ifdef GLD_DEBUG
1104                         if (gld_debug & GLDERRS)
1105                                 cmn_err(CE_WARN,
1106                                     "GLD: interpret_fddi cannot msgpullup2");
1107 #endif
1108                         goto out;       /* can't interpret this pkt further */
1109                 }
1110                 mp = pmp;       /* this mblk should contain everything needed */
1111         }
1112 
1113         /*
1114          * Check SAP/SNAP information.
1115          */
1116         if ((mh->fddi_fc & 0x70) == 0x50) {
1117                 if (pktinfo->pktLen < pktinfo->macLen + LLC_HDR1_LEN)
1118                         goto out;
1119 
1120                 pktinfo->isLLC = 1;
1121 
1122                 if (pktinfo->pktLen < pktinfo->macLen + LLC_SNAP_HDR_LEN)
1123                         goto out;
1124 
1125                 snaphdr = (struct llc_snap_hdr *)(mp->b_rptr + pktinfo->macLen);
1126                 if (ISETHERTYPE(snaphdr)) {
1127                         pktinfo->ethertype = REF_NET_USHORT(snaphdr->type);
1128                         pktinfo->hdrLen = LLC_SNAP_HDR_LEN;
1129                 }
1130         }
1131 out:
1132         if (pmp != NULL)
1133                 freemsg(pmp);
1134 
1135         return (0);
1136 }
1137 
1138 mblk_t *
1139 gld_unitdata_fddi(gld_t *gld, mblk_t *mp)
1140 {
1141         gld_mac_info_t *macinfo = gld->gld_mac_info;
1142         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
1143         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
1144         mac_addr_t dhost;
1145         unsigned short type;
1146         mblk_t *nmp;
1147         struct fddi_mac_frm *mh;
1148         int hdrlen;
1149 
1150         ASSERT(macinfo);
1151 
1152         /* extract needed info from the mblk before we maybe reuse it */
1153         mac_copy(gldp->glda_addr, dhost, macinfo->gldm_addrlen);
1154 
1155         /* look in the unitdata request for a sap, else use bound one */
1156         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
1157             REF_HOST_USHORT(gldp->glda_sap) != 0)
1158                 type = REF_HOST_USHORT(gldp->glda_sap);
1159         else
1160                 type = gld->gld_sap;
1161 
1162 
1163         hdrlen = sizeof (struct fddi_mac_frm);
1164 
1165         /*
1166          * Check whether we need to do EtherType encoding or whether the packet
1167          * is LLC.
1168          */
1169         if (type > GLD_MAX_802_SAP)
1170                 hdrlen += sizeof (struct llc_snap_hdr);
1171 
1172         /* need a buffer big enough for the headers */
1173         nmp = mp->b_cont;    /* where the packet payload M_DATA is */
1174         if (DB_REF(nmp) == 1 && MBLKHEAD(nmp) >= hdrlen) {
1175                 /* it fits at the beginning of the first M_DATA block */
1176                 freeb(mp);      /* don't need the M_PROTO anymore */
1177         } else if (DB_REF(mp) == 1 && MBLKSIZE(mp) >= hdrlen) {
1178                 /* we can reuse the dl_unitdata_req M_PROTO mblk */
1179                 nmp = mp;
1180                 DB_TYPE(nmp) = M_DATA;
1181                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1182         } else {
1183                 /* we need to allocate one */
1184                 if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
1185                         return (NULL);
1186                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1187                 linkb(nmp, mp->b_cont);
1188                 freeb(mp);
1189         }
1190 
1191 
1192         /* Got the space, now copy in the header components */
1193         if (type > GLD_MAX_802_SAP) {
1194                 /* create the snap header */
1195                 struct llc_snap_hdr *snap;
1196                 nmp->b_rptr -= sizeof (struct llc_snap_hdr);
1197                 snap  = (struct llc_snap_hdr *)(nmp->b_rptr);
1198                 *snap = llc_snap_def;
1199                 SET_NET_USHORT(snap->type, type);
1200         }
1201 
1202         nmp->b_rptr -= sizeof (struct fddi_mac_frm);
1203 
1204         mh = (struct fddi_mac_frm *)nmp->b_rptr;
1205 
1206         mh->fddi_fc = 0x50;
1207         cmac_copy(dhost, mh->fddi_dhost, macinfo->gldm_addrlen, macinfo);
1208 
1209         /*
1210          * We access the mac address without the mutex to prevent
1211          * mutex contention (BUG 4211361)
1212          */
1213         cmac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1214             mh->fddi_shost, macinfo->gldm_addrlen, macinfo);
1215         return (nmp);
1216 }
1217 
1218 mblk_t *
1219 gld_fastpath_fddi(gld_t *gld, mblk_t *mp)
1220 {
1221         gld_mac_info_t *macinfo = gld->gld_mac_info;
1222         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_cont->b_rptr;
1223         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
1224         unsigned short type;
1225         mblk_t *nmp;
1226         struct fddi_mac_frm *mh;
1227         int hdrlen;
1228 
1229         ASSERT(macinfo);
1230 
1231         /* look in the unitdata request for a sap, else use bound one */
1232         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
1233             REF_HOST_USHORT(gldp->glda_sap) != 0)
1234                 type = REF_HOST_USHORT(gldp->glda_sap);
1235         else
1236                 type = gld->gld_sap;
1237 
1238         hdrlen = sizeof (struct fddi_mac_frm);
1239 
1240         /*
1241          * Check whether we need to do EtherType encoding or whether the packet
1242          * will be LLC.
1243          */
1244         if (type > GLD_MAX_802_SAP)
1245                 hdrlen += sizeof (struct llc_snap_hdr);
1246 
1247         if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
1248                 return (NULL);
1249 
1250         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1251 
1252         /* Got the space, now copy in the header components */
1253 
1254         if (type > GLD_MAX_802_SAP) {
1255                 /* create the snap header */
1256                 struct llc_snap_hdr *snap;
1257                 nmp->b_rptr -= sizeof (struct llc_snap_hdr);
1258                 snap  = (struct llc_snap_hdr *)(nmp->b_rptr);
1259                 *snap = llc_snap_def;
1260                 snap->type = htons(type);    /* we know it's aligned */
1261         }
1262 
1263         nmp->b_rptr -= sizeof (struct fddi_mac_frm);
1264 
1265         mh = (struct fddi_mac_frm *)nmp->b_rptr;
1266         mh->fddi_fc = 0x50;
1267         cmac_copy(gldp->glda_addr, mh->fddi_dhost,
1268             macinfo->gldm_addrlen, macinfo);
1269 
1270         GLDM_LOCK(macinfo, RW_WRITER);
1271         cmac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1272             mh->fddi_shost, macinfo->gldm_addrlen, macinfo);
1273         GLDM_UNLOCK(macinfo);
1274 
1275         return (nmp);
1276 }
1277 
1278 /* ========== */
1279 /* Token Ring */
1280 /* ========== */
1281 
1282 #define GLD_SR_VAR(macinfo)     \
1283         (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->data)
1284 
1285 #define GLD_SR_HASH(macinfo)    ((struct srtab **)GLD_SR_VAR(macinfo))
1286 
1287 #define GLD_SR_MUTEX(macinfo)   \
1288         (&((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->datalock)
1289 
1290 static void gld_sr_clear(gld_mac_info_t *);
1291 static void gld_rcc_receive(gld_mac_info_t *, pktinfo_t *, struct gld_ri *,
1292     uchar_t *, int);
1293 static void gld_rcc_send(gld_mac_info_t *, queue_t *, uchar_t *,
1294     struct gld_ri **, uchar_t *);
1295 
1296 static mac_addr_t tokenbroadcastaddr2 = { 0xc0, 0x00, 0xff, 0xff, 0xff, 0xff };
1297 static struct gld_ri ri_ste_def;
1298 
1299 void
1300 gld_init_tr(gld_mac_info_t *macinfo)
1301 {
1302         struct gldkstats *sp =
1303             ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->kstatp->ks_data;
1304 
1305         /* avoid endian-dependent code by initializing here instead of static */
1306         ri_ste_def.len = 2;
1307         ri_ste_def.rt = RT_STE;
1308         ri_ste_def.mtu = RT_MTU_MAX;
1309         ri_ste_def.dir = 0;
1310         ri_ste_def.res = 0;
1311 
1312         /* Assumptions we make for this medium */
1313         ASSERT(macinfo->gldm_type == DL_TPR);
1314         ASSERT(macinfo->gldm_addrlen == 6);
1315         ASSERT(macinfo->gldm_saplen == -2);
1316 #ifndef lint
1317         ASSERT(sizeof (struct tr_mac_frm_nori) == 14);
1318         ASSERT(sizeof (mac_addr_t) == 6);
1319 #endif
1320 
1321         mutex_init(GLD_SR_MUTEX(macinfo), NULL, MUTEX_DRIVER, NULL);
1322 
1323         GLD_SR_VAR(macinfo) = kmem_zalloc(sizeof (struct srtab *)*SR_HASH_SIZE,
1324                                 KM_SLEEP);
1325 
1326         /* Default is RDE enabled for this medium */
1327         ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_enabled =
1328             ddi_getprop(DDI_DEV_T_NONE, macinfo->gldm_devinfo, 0,
1329             "gld_rde_enable", 1);
1330 
1331         /*
1332          * Default is to use STE for unknown paths if RDE is enabled.
1333          * If RDE is disabled, default is to use NULL RIF fields.
1334          *
1335          * It's possible to force use of STE for ALL packets:
1336          * disable RDE but enable STE.  This may be useful for
1337          * non-transparent bridges, when it is not desired to run
1338          * the RDE algorithms.
1339          */
1340         ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_str_indicator_ste =
1341             ddi_getprop(DDI_DEV_T_NONE, macinfo->gldm_devinfo, 0,
1342             "gld_rde_str_indicator_ste",
1343             ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_enabled);
1344 
1345         /* Default 10 second route timeout on lack of activity */
1346         {
1347         int t = ddi_getprop(DDI_DEV_T_NONE, macinfo->gldm_devinfo, 0,
1348             "gld_rde_timeout", 10);
1349         if (t < 1)
1350                 t = 1;          /* Let's be reasonable */
1351         if (t > 600)
1352                 t = 600;        /* Let's be reasonable */
1353         /* We're using ticks (lbolts) for our timeout -- convert from seconds */
1354         t = drv_sectohz(t);
1355         ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_timeout = t;
1356         }
1357 
1358         kstat_named_init(&sp->glds_dot5_line_error,
1359             "line_errors", KSTAT_DATA_UINT32);
1360         kstat_named_init(&sp->glds_dot5_burst_error,
1361             "burst_errors", KSTAT_DATA_UINT32);
1362         kstat_named_init(&sp->glds_dot5_signal_loss,
1363             "signal_losses", KSTAT_DATA_UINT32);
1364 
1365         /*
1366          * only initialize the new statistics if the driver
1367          * knows about them.
1368          */
1369         if (macinfo->gldm_driver_version != GLD_VERSION_200)
1370                 return;
1371 
1372         kstat_named_init(&sp->glds_dot5_ace_error,
1373             "ace_errors", KSTAT_DATA_UINT32);
1374         kstat_named_init(&sp->glds_dot5_internal_error,
1375             "internal_errors", KSTAT_DATA_UINT32);
1376         kstat_named_init(&sp->glds_dot5_lost_frame_error,
1377             "lost_frame_errors", KSTAT_DATA_UINT32);
1378         kstat_named_init(&sp->glds_dot5_frame_copied_error,
1379             "frame_copied_errors", KSTAT_DATA_UINT32);
1380         kstat_named_init(&sp->glds_dot5_token_error,
1381             "token_errors", KSTAT_DATA_UINT32);
1382         kstat_named_init(&sp->glds_dot5_freq_error,
1383             "freq_errors", KSTAT_DATA_UINT32);
1384 }
1385 
1386 void
1387 gld_uninit_tr(gld_mac_info_t *macinfo)
1388 {
1389         mutex_destroy(GLD_SR_MUTEX(macinfo));
1390         gld_sr_clear(macinfo);
1391         kmem_free(GLD_SR_VAR(macinfo), sizeof (struct srtab *) * SR_HASH_SIZE);
1392 }
1393 
1394 int
1395 gld_interpret_tr(gld_mac_info_t *macinfo, mblk_t *mp, pktinfo_t *pktinfo,
1396     packet_flag_t flags)
1397 {
1398         struct tr_mac_frm *mh;
1399         gld_mac_pvt_t *mac_pvt;
1400         struct llc_snap_hdr *snaphdr;
1401         mblk_t *pmp = NULL;
1402         struct gld_ri *rh;
1403 
1404         /*
1405          * Quickly handle receive fastpath; TR does not support IPQ hack.
1406          */
1407         if (flags == GLD_RXQUICK) {
1408                 pktinfo->pktLen = msgdsize(mp);
1409                 return (-1);
1410         }
1411 
1412         bzero((void *)pktinfo, sizeof (*pktinfo));
1413 
1414         pktinfo->pktLen = msgdsize(mp);
1415 
1416         /* make sure packet has at least a whole mac header */
1417         if (pktinfo->pktLen < sizeof (struct tr_mac_frm_nori))
1418                 return (-1);
1419 
1420         /* make sure the mac header falls into contiguous memory */
1421         if (MBLKL(mp) < sizeof (struct tr_mac_frm_nori)) {
1422                 if ((pmp = msgpullup(mp, -1)) == NULL) {
1423 #ifdef GLD_DEBUG
1424                         if (gld_debug & GLDERRS)
1425                                 cmn_err(CE_WARN,
1426                                     "GLD: interpret_tr cannot msgpullup");
1427 #endif
1428                         return (-1);
1429                 }
1430                 mp = pmp;       /* this mblk contains the whole mac header */
1431         }
1432 
1433         mh = (struct tr_mac_frm *)mp->b_rptr;
1434 
1435         /* Check to see if the mac is a broadcast or multicast address. */
1436         if (mac_eq(mh->tr_dhost, ether_broadcast, macinfo->gldm_addrlen) ||
1437             mac_eq(mh->tr_dhost, tokenbroadcastaddr2, macinfo->gldm_addrlen))
1438                 pktinfo->isBroadcast = 1;
1439         else if (mh->tr_dhost[0] & 0x80)
1440                 pktinfo->isMulticast = 1;
1441 
1442         if (flags == GLD_TX)
1443                 goto out;       /* Got all info we need for xmit case */
1444 
1445         ASSERT(GLDM_LOCK_HELD(macinfo));
1446 
1447         /*
1448          * Deal with the mac header
1449          */
1450 
1451         mac_copy(mh->tr_dhost, pktinfo->dhost, macinfo->gldm_addrlen);
1452         mac_copy(mh->tr_shost, pktinfo->shost, macinfo->gldm_addrlen);
1453         pktinfo->shost[0] &= ~0x80;      /* turn off RIF indicator */
1454 
1455         mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
1456         pktinfo->isLooped = mac_eq(pktinfo->shost,
1457             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
1458         pktinfo->isForMe = mac_eq(pktinfo->dhost,
1459             mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
1460 
1461         rh = (struct gld_ri *)NULL;
1462         pktinfo->macLen = sizeof (struct tr_mac_frm_nori);
1463 
1464         /*
1465          * Before trying to look beyond the MAC header, make sure the data
1466          * structures are all contiguously where we can conveniently look at
1467          * them.  We'll use a worst-case estimate of how many bytes into the
1468          * packet data we'll be needing to look.  Things will be more efficient
1469          * if the driver puts at least this much into the first mblk.
1470          *
1471          * Even after this, we still will have to do checks against the total
1472          * length of the packet.  A bad incoming packet may not hold all the
1473          * data structures it says it does.
1474          */
1475         if (MBLKL(mp) < sizeof (struct tr_mac_frm) +
1476             LLC_HDR1_LEN + sizeof (struct rde_pdu) &&
1477             MBLKL(mp) < pktinfo->pktLen) {
1478                 /*
1479                  * we don't have the entire packet within the first mblk (and
1480                  * therefore we didn't do the msgpullup above), AND the first
1481                  * mblk may not contain all the data we need to look at.
1482                  */
1483                 ASSERT(pmp == NULL);    /* couldn't have done msgpullup above */
1484                 if ((pmp = msgpullup(mp, -1)) == NULL) {
1485 #ifdef GLD_DEBUG
1486                         if (gld_debug & GLDERRS)
1487                                 cmn_err(CE_WARN,
1488                                     "GLD: interpret_tr cannot msgpullup2");
1489 #endif
1490                         goto out;       /* can't interpret this pkt further */
1491                 }
1492                 mp = pmp;       /* this mblk should contain everything needed */
1493                 mh = (struct tr_mac_frm *)mp->b_rptr;        /* to look at RIF */
1494         }
1495 
1496         if (mh->tr_shost[0] & 0x80) {
1497                 /* Routing Information Field (RIF) is present */
1498                 if (pktinfo->pktLen < sizeof (struct tr_mac_frm_nori) + 2)
1499                         goto out;       /* RIF should have been there! */
1500                 rh = (struct gld_ri *)&mh->tr_ri;
1501                 if ((rh->len & 1) || rh->len < 2) {
1502                         /* Bogus RIF, don't handle this packet */
1503 #ifdef GLD_DEBUG
1504                         if (gld_debug & GLDERRS)
1505                                 cmn_err(CE_WARN,
1506                                     "GLD: received TR packet with "
1507                                     "bogus RIF length %d",
1508                                     rh->len);
1509 #endif
1510                         goto out;
1511                 }
1512                 if (pktinfo->pktLen < sizeof (struct tr_mac_frm_nori) + rh->len)
1513                         goto out;       /* RIF should have been there! */
1514                 pktinfo->macLen += rh->len;
1515         }
1516 
1517         if ((mh->tr_fc & 0xc0) == 0x40) {
1518                 if (pktinfo->pktLen < pktinfo->macLen + LLC_HDR1_LEN)
1519                         goto out;
1520 
1521                 pktinfo->isLLC = 1;
1522 
1523                 if (pktinfo->pktLen < pktinfo->macLen + LLC_SNAP_HDR_LEN)
1524                         goto out;
1525 
1526                 snaphdr = (struct llc_snap_hdr *)(mp->b_rptr + pktinfo->macLen);
1527                 if (ISETHERTYPE(snaphdr)) {
1528                         pktinfo->ethertype = REF_NET_USHORT(snaphdr->type);
1529                         pktinfo->hdrLen = LLC_SNAP_HDR_LEN;
1530                 }
1531 
1532                 /* Inform the Route Control Component of received LLC frame */
1533                 gld_rcc_receive(macinfo, pktinfo, rh,
1534                     mp->b_rptr + pktinfo->macLen,
1535                     pktinfo->pktLen - pktinfo->macLen);
1536         }
1537 out:
1538         if (pmp != NULL)
1539                 freemsg(pmp);
1540 
1541         return (0);
1542 }
1543 
1544 mblk_t *
1545 gld_unitdata_tr(gld_t *gld, mblk_t *mp)
1546 {
1547         gld_mac_info_t *macinfo = gld->gld_mac_info;
1548         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
1549         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
1550         mac_addr_t dhost;
1551         unsigned short type;
1552         mblk_t *nmp, *llcmp, *pmp = NULL;
1553         struct tr_mac_frm_nori *mh;
1554         int hdrlen;
1555         struct gld_ri *rh;
1556 
1557         ASSERT(macinfo);
1558 
1559         /* extract needed info from the mblk before we maybe reuse it */
1560         mac_copy(gldp->glda_addr, dhost, macinfo->gldm_addrlen);
1561 
1562         /* look in the unitdata request for a sap, else use bound one */
1563         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
1564             REF_HOST_USHORT(gldp->glda_sap) != 0)
1565                 type = REF_HOST_USHORT(gldp->glda_sap);
1566         else
1567                 type = gld->gld_sap;
1568 
1569         /* includes maximum possible Routing Information Field (RIF) size */
1570         hdrlen = sizeof (struct tr_mac_frm);
1571 
1572         /*
1573          * Check whether we need to do EtherType encoding or whether the packet
1574          * is LLC.
1575          */
1576         if (type > GLD_MAX_802_SAP)
1577                 hdrlen += sizeof (struct llc_snap_hdr);
1578 
1579         /* need a buffer big enough for the headers */
1580         llcmp = nmp = mp->b_cont; /* where the packet payload M_DATA is */
1581 
1582         /*
1583          * We are going to need to look at the LLC header, so make sure it
1584          * is contiguously in a single mblk.  If we're the ones who create
1585          * the LLC header (below, in the case where sap > 0xff) then we don't
1586          * have to worry about it here.
1587          */
1588         ASSERT(nmp != NULL);    /* gld_unitdata guarantees msgdsize > 0 */
1589         if (type <= GLD_MAX_802_SAP) {
1590                 if (MBLKL(llcmp) < LLC_HDR1_LEN) {
1591                         llcmp = pmp = msgpullup(nmp, LLC_HDR1_LEN);
1592                         if (pmp == NULL) {
1593 #ifdef GLD_DEBUG
1594                                 if (gld_debug & GLDERRS)
1595                                         cmn_err(CE_WARN,
1596                                             "GLD: unitdata_tr "
1597                                             "cannot msgpullup");
1598 #endif
1599                                 return (NULL);
1600                         }
1601                 }
1602         }
1603 
1604         if (DB_REF(nmp) == 1 && MBLKHEAD(nmp) >= hdrlen) {
1605                 /* it fits at the beginning of the first M_DATA block */
1606                 freeb(mp);      /* don't need the M_PROTO anymore */
1607         } else if (DB_REF(mp) == 1 && MBLKSIZE(mp) >= hdrlen) {
1608                 /* we can reuse the dl_unitdata_req M_PROTO mblk */
1609                 nmp = mp;
1610                 DB_TYPE(nmp) = M_DATA;
1611                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1612         } else {
1613                 /* we need to allocate one */
1614                 if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL) {
1615                         if (pmp != NULL)
1616                                 freemsg(pmp);
1617                         return (NULL);
1618                 }
1619                 nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1620                 linkb(nmp, mp->b_cont);
1621                 freeb(mp);
1622         }
1623 
1624         /* Got the space, now copy in the header components */
1625         if (type > GLD_MAX_802_SAP) {
1626                 /* create the snap header */
1627                 struct llc_snap_hdr *snap;
1628                 llcmp = nmp;    /* LLC header is going to be in this mblk */
1629                 nmp->b_rptr -= sizeof (struct llc_snap_hdr);
1630                 snap  = (struct llc_snap_hdr *)(nmp->b_rptr);
1631                 *snap = llc_snap_def;
1632                 SET_NET_USHORT(snap->type, type);
1633         }
1634 
1635         /* Hold SR tables still while we maybe point at an entry */
1636         mutex_enter(GLD_SR_MUTEX(macinfo));
1637 
1638         gld_rcc_send(macinfo, WR(gld->gld_qptr), dhost, &rh, llcmp->b_rptr);
1639 
1640         if (rh != NULL) {
1641                 /* copy in the RIF */
1642                 ASSERT(rh->len <= sizeof (struct gld_ri));
1643                 nmp->b_rptr -= rh->len;
1644                 bcopy((caddr_t)rh, (caddr_t)nmp->b_rptr, rh->len);
1645         }
1646 
1647         mutex_exit(GLD_SR_MUTEX(macinfo));
1648 
1649         /* no longer need the pulled-up mblk */
1650         if (pmp != NULL)
1651                 freemsg(pmp);
1652 
1653         /*
1654          * fill in token ring header
1655          */
1656         nmp->b_rptr -= sizeof (struct tr_mac_frm_nori);
1657         mh = (struct tr_mac_frm_nori *)nmp->b_rptr;
1658         mh->tr_ac = 0x10;
1659         mh->tr_fc = 0x40;
1660         mac_copy(dhost, mh->tr_dhost, macinfo->gldm_addrlen);
1661 
1662         /*
1663          * We access the mac address without the mutex to prevent
1664          * mutex contention (BUG 4211361)
1665          */
1666         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1667             mh->tr_shost, macinfo->gldm_addrlen);
1668 
1669         if (rh != NULL)
1670                 mh->tr_shost[0] |= 0x80;
1671         else
1672                 mh->tr_shost[0] &= ~0x80;
1673 
1674         return (nmp);
1675 }
1676 
1677 /*
1678  * We cannot have our client sending us "fastpath" M_DATA messages,
1679  * because to do that we must provide to him a fixed MAC header to
1680  * be prepended to each outgoing packet.  But with Source Routing
1681  * media, the length and content of the MAC header changes as the
1682  * routes change, so there is no fixed header we can provide.  So
1683  * we decline to accept M_DATA messages if Source Routing is enabled.
1684  */
1685 mblk_t *
1686 gld_fastpath_tr(gld_t *gld, mblk_t *mp)
1687 {
1688         gld_mac_info_t *macinfo = gld->gld_mac_info;
1689         dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_cont->b_rptr;
1690         struct gld_dlsap *gldp = DLSAP(dlp, dlp->dl_dest_addr_offset);
1691         unsigned short type;
1692         mblk_t *nmp;
1693         struct tr_mac_frm_nori *mh;
1694         int hdrlen;
1695 
1696         ASSERT(macinfo);
1697 
1698         /*
1699          * If we are doing Source Routing, then we cannot provide a fixed
1700          * MAC header, so fail.
1701          */
1702         if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_enabled)
1703                 return (NULL);
1704 
1705         /* look in the unitdata request for a sap, else use bound one */
1706         if (dlp->dl_dest_addr_length >= DLSAPLENGTH(macinfo) &&
1707             REF_HOST_USHORT(gldp->glda_sap) != 0)
1708                 type = REF_HOST_USHORT(gldp->glda_sap);
1709         else
1710                 type = gld->gld_sap;
1711 
1712         hdrlen = sizeof (struct tr_mac_frm_nori);
1713 
1714         if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_str_indicator_ste)
1715                 hdrlen += ri_ste_def.len;
1716 
1717         /*
1718          * Check whether we need to do EtherType encoding or whether the packet
1719          * will be LLC.
1720          */
1721         if (type > GLD_MAX_802_SAP)
1722                 hdrlen += sizeof (struct llc_snap_hdr);
1723 
1724         if ((nmp = allocb(hdrlen, BPRI_MED)) == NULL)
1725                 return (NULL);
1726 
1727         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1728 
1729         /* Got the space, now copy in the header components */
1730 
1731         if (type > GLD_MAX_802_SAP) {
1732                 /* create the snap header */
1733                 struct llc_snap_hdr *snap;
1734                 nmp->b_rptr -= sizeof (struct llc_snap_hdr);
1735                 snap  = (struct llc_snap_hdr *)(nmp->b_rptr);
1736                 *snap = llc_snap_def;
1737                 snap->type = htons(type);    /* we know it's aligned */
1738         }
1739 
1740         /* RDE is disabled, use NULL RIF, or STE RIF */
1741         if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_str_indicator_ste) {
1742                 nmp->b_rptr -= ri_ste_def.len;
1743                 bcopy((caddr_t)&ri_ste_def, (caddr_t)nmp->b_rptr,
1744                     ri_ste_def.len);
1745         }
1746 
1747         /*
1748          * fill in token ring header
1749          */
1750         nmp->b_rptr -= sizeof (struct tr_mac_frm_nori);
1751         mh = (struct tr_mac_frm_nori *)nmp->b_rptr;
1752         mh->tr_ac = 0x10;
1753         mh->tr_fc = 0x40;
1754         mac_copy(gldp->glda_addr, mh->tr_dhost, macinfo->gldm_addrlen);
1755 
1756         GLDM_LOCK(macinfo, RW_WRITER);
1757         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1758             mh->tr_shost, macinfo->gldm_addrlen);
1759         GLDM_UNLOCK(macinfo);
1760 
1761         if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_str_indicator_ste)
1762                 mh->tr_shost[0] |= 0x80;
1763         else
1764                 mh->tr_shost[0] &= ~0x80;
1765 
1766         return (nmp);
1767 }
1768 
1769 /*
1770  * Route Determination Entity (ISO 8802-2 / IEEE 802.2 : 1994, Section 9)
1771  *
1772  * RDE is an LLC layer entity.  GLD is a MAC layer entity.  The proper
1773  * solution to this architectural anomaly is to move RDE support out of GLD
1774  * and into LLC where it belongs.  In particular, only LLC has the knowledge
1775  * necessary to reply to XID and TEST packets.  If and when it comes time to
1776  * move RDE out of GLD to LLC, the LLC-to-GLD interface should be modified
1777  * to use MA_UNITDATA structures rather than DL_UNITDATA structures.  Of
1778  * course, GLD will still have to continue to also support the DL_ structures
1779  * as long as IP is not layered over LLC.  Another, perhaps better, idea
1780  * would be to make RDE an autopush module on top of the token ring drivers:
1781  * RDE would sit between LLC and GLD.  It would then also sit between IP and
1782  * GLD, providing services to all clients of GLD/tokenring.  In that case,
1783  * GLD would still have to continue to support the DL_ interface for non-
1784  * Token Ring interfaces, using the MA_ interface only for media supporting
1785  * Source Routing media.
1786  *
1787  * At present, Token Ring is the only source routing medium we support.
1788  * Since Token Ring is not at this time a strategic network medium for Sun,
1789  * rather than devote a large amount of resources to creating a proper
1790  * architecture and implementation of RDE, we do the minimum necessary to
1791  * get it to work.  The interface between the above token ring code and the
1792  * below RDE code is designed to make it relatively easy to change to an
1793  * MA_UNITDATA model later should this ever become a priority.
1794  */
1795 
1796 static void gld_send_rqr(gld_mac_info_t *, uchar_t *, struct gld_ri *,
1797     struct rde_pdu *, int);
1798 static void gld_rde_pdu_req(gld_mac_info_t *, queue_t *, uchar_t *,
1799     struct gld_ri *, uchar_t, uchar_t, uchar_t);
1800 static void gld_get_route(gld_mac_info_t *, queue_t *, uchar_t *,
1801     struct gld_ri **, uchar_t, uchar_t);
1802 static void gld_reset_route(gld_mac_info_t *, queue_t *,
1803     uchar_t *, uchar_t, uchar_t);
1804 static void gld_rde_pdu_ind(gld_mac_info_t *, struct gld_ri *, struct rde_pdu *,
1805     int);
1806 static void gld_rif_ind(gld_mac_info_t *, struct gld_ri *, uchar_t *,
1807     uchar_t, uchar_t);
1808 static struct srtab **gld_sr_hash(struct srtab **, uchar_t *, int);
1809 static struct srtab *gld_sr_lookup_entry(gld_mac_info_t *, uchar_t *);
1810 static struct srtab *gld_sr_create_entry(gld_mac_info_t *, uchar_t *);
1811 
1812 /*
1813  * This routine implements a modified subset of the 802.2 RDE RCC receive
1814  * actions:
1815  *   we implement RCC receive events 3 to 12 (ISO 8802-2:1994 9.6.3.4);
1816  *   we omit special handling for the NULL SAP;
1817  *   we omit XID/TEST handling;
1818  *   we pass all packets (including RDE) upstream to LLC.
1819  */
1820 static void
1821 gld_rcc_receive(gld_mac_info_t *macinfo, pktinfo_t *pktinfo, struct gld_ri *rh,
1822     uchar_t *llcpkt, int llcpktlen)
1823 {
1824         struct llc_snap_hdr *snaphdr = (struct llc_snap_hdr *)(llcpkt);
1825 
1826         if (!((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_enabled)
1827                 return;
1828 
1829         /*
1830          * First, ensure this packet wasn't something we received just
1831          * because we were in promiscuous mode.  Since none of the below
1832          * code wants to see group addressed packets anyway, we can do
1833          * this check up front.  Since we're doing that, we can omit the
1834          * checks for group addressed packets below.
1835          */
1836         if (!pktinfo->isForMe)
1837                 return;         /* Event 6 */
1838 
1839         /* Process a subset of Route Determination Entity (RDE) packets */
1840         if (snaphdr->d_lsap == LSAP_RDE) {
1841                 struct rde_pdu *pdu = (struct rde_pdu *)(llcpkt + LLC_HDR1_LEN);
1842                 int pdulen = llcpktlen - LLC_HDR1_LEN;
1843 
1844                 /* sanity check the PDU */
1845                 if ((pdulen < sizeof (struct rde_pdu)) ||
1846                     (snaphdr->s_lsap != LSAP_RDE))
1847                         return;
1848 
1849                 /* we only handle route discovery PDUs, not XID/TEST/other */
1850                 if (snaphdr->control != CNTL_LLC_UI)
1851                         return;
1852 
1853                 switch (pdu->rde_ptype) {
1854                 case RDE_RQC:   /* Route Query Command; Events 8 - 11 */
1855                         gld_send_rqr(macinfo, pktinfo->shost, rh, pdu, pdulen);
1856                         /* FALLTHROUGH */
1857                 case RDE_RQR:   /* Route Query Response; Event 12 */
1858                 case RDE_RS:    /* Route Selected; Event 7 */
1859                         gld_rde_pdu_ind(macinfo, rh, pdu, pdulen);
1860                         break;
1861                 default:        /* ignore if unrecognized ptype */
1862                         return;
1863                 }
1864 
1865                 return;
1866         }
1867 
1868         /* Consider routes seen in other IA SRF packets */
1869 
1870         if (rh == NULL)
1871                 return;         /* no RIF; Event 3 */
1872 
1873         if ((rh->rt & 0x04) != 0)
1874                 return;         /* not SRF; Event 5 */
1875 
1876         gld_rif_ind(macinfo, rh, pktinfo->shost, snaphdr->s_lsap,
1877             snaphdr->d_lsap);        /* Event 4 */
1878 }
1879 
1880 /*
1881  * Send RQR: 802.2 9.6.3.4.2(9) RCC Receive Events 8-11
1882  *
1883  * The routing processing really doesn't belong here; it should be handled in
1884  * the LLC layer above.  If that were the case then RDE could just send down
1885  * an extra MA_UNITDATA_REQ with the info needed to construct the packet.  But
1886  * at the time we get control here, it's not a particularly good time to be
1887  * constructing packets and trying to send them.  Specifically, at this layer
1888  * we need to construct the full media packet, which means the below routine
1889  * knows that it is dealing with Token Ring media.  If this were instead done
1890  * via a proper MA_UNITDATA interface, the RDE stuff could all be completely
1891  * media independent.  But since TR is the only source routing medium we
1892  * support, this works even though it is not clean.
1893  *
1894  * We "know" that the only time we can get here is from the "interpret"
1895  * routine, and only when it was called at receive time.
1896  */
1897 static void
1898 gld_send_rqr(gld_mac_info_t *macinfo, uchar_t *shost, struct gld_ri *rh,
1899     struct rde_pdu *pdu, int pdulen)
1900 {
1901         mblk_t *nmp;
1902         int nlen;
1903         struct tr_mac_frm_nori *nmh;
1904         struct gld_ri *nrh;
1905         struct llc_snap_hdr *nsnaphdr;
1906         struct rde_pdu *npdu;
1907 
1908         /* We know and assume we're on the receive path */
1909         ASSERT(GLDM_LOCK_HELD(macinfo));
1910 
1911         if (pdulen < sizeof (struct rde_pdu))
1912                 return;         /* Bad incoming PDU */
1913 
1914         nlen = sizeof (struct tr_mac_frm) + LLC_HDR1_LEN +
1915             sizeof (struct rde_pdu);
1916 
1917         if ((nmp = allocb(nlen, BPRI_MED)) == NULL)
1918                 return;
1919 
1920         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
1921 
1922         nmp->b_rptr -= sizeof (struct rde_pdu);
1923         npdu = (struct rde_pdu *)(nmp->b_rptr);
1924         *npdu = *pdu;   /* copy orig/target macaddr/saps */
1925         npdu->rde_ver = 1;
1926         npdu->rde_ptype = RDE_RQR;
1927         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1928             npdu->rde_target_mac, macinfo->gldm_addrlen);
1929 
1930         nmp->b_rptr -= LLC_HDR1_LEN;
1931         nsnaphdr = (struct llc_snap_hdr *)(nmp->b_rptr);
1932         nsnaphdr->s_lsap = nsnaphdr->d_lsap = LSAP_RDE;
1933         nsnaphdr->control = CNTL_LLC_UI;
1934 
1935         if (rh == NULL || (rh->rt & 0x06) == 0x06 ||
1936             rh->len > sizeof (struct gld_ri)) {
1937                 /* no RIF (Event 8), or RIF type STE (Event 9): send ARE RQR */
1938                 nmp->b_rptr -= 2;
1939                 nrh = (struct gld_ri *)(nmp->b_rptr);
1940                 nrh->len = 2;
1941                 nrh->rt = RT_ARE;
1942                 nrh->dir = 0;
1943                 nrh->res = 0;
1944                 nrh->mtu = RT_MTU_MAX;
1945         } else {
1946                 /*
1947                  * RIF must be ARE (Event 10) or SRF (Event 11):
1948                  * send SRF (reverse) RQR
1949                  */
1950                 ASSERT(rh->len <= sizeof (struct gld_ri));
1951                 nmp->b_rptr -= rh->len;
1952                 nrh = (struct gld_ri *)(nmp->b_rptr);
1953                 bcopy(rh, nrh, rh->len);     /* copy incoming RIF */
1954                 nrh->rt = RT_SRF;            /* make it SRF */
1955                 nrh->dir ^= 1;                       /* reverse direction */
1956         }
1957 
1958         nmp->b_rptr -= sizeof (struct tr_mac_frm_nori);
1959         nmh = (struct tr_mac_frm_nori *)(nmp->b_rptr);
1960         nmh->tr_ac = 0x10;
1961         nmh->tr_fc = 0x40;
1962         mac_copy(shost, nmh->tr_dhost, macinfo->gldm_addrlen);
1963         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
1964             nmh->tr_shost, macinfo->gldm_addrlen);
1965         nmh->tr_shost[0] |= 0x80;            /* indicate RIF present */
1966 
1967         /*
1968          * Packet assembled; send it.
1969          *
1970          * As noted before, this is not really a good time to be trying to
1971          * send out packets.  We have no obvious queue to use if the packet
1972          * can't be sent right away.  We pick one arbitrarily.
1973          */
1974         {
1975         gld_vlan_t *vlan;
1976         queue_t *q;
1977 
1978         if ((vlan = gld_find_vlan(macinfo, VLAN_VID_NONE)) == NULL) {
1979                 /* oops, no vlan on the list for this macinfo! */
1980                 /* this should not happen */
1981                 freeb(nmp);
1982                 return;
1983         }
1984         q = vlan->gldv_str_next->gld_qptr;
1985 
1986         /*
1987          * Queue the packet and let gld_wsrv
1988          * handle it, thus preventing a panic
1989          * caused by v2 TR in promiscuous mode
1990          * where it attempts to get the mutex
1991          * in this thread while already holding
1992          * it.
1993          */
1994         (void) putbq(WR(q), nmp);
1995         qenable(WR(q));
1996         }
1997 }
1998 
1999 /*
2000  * This routine implements a modified subset of the 802.2 RDE RCC send actions:
2001  *   we implement RCC send events 5 to 10 (ISO 8802-2:1994 9.6.3.5);
2002  *   we omit special handling for the NULL SAP;
2003  *   events 11 to 12 are handled by gld_rde_pdu_req below;
2004  *   we require an immediate response to our GET_ROUTE_REQUEST.
2005  */
2006 static void
2007 gld_rcc_send(gld_mac_info_t *macinfo, queue_t *q, uchar_t *dhost,
2008     struct gld_ri **rhp, uchar_t *llcpkt)
2009 {
2010         struct llc_snap_hdr *snaphdr = (struct llc_snap_hdr *)(llcpkt);
2011 
2012         /*
2013          * Our caller has to take the mutex because: to avoid an extra bcopy
2014          * of the RIF on every transmit, we pass back a pointer to our sr
2015          * table entry via rhp.  He has to keep the mutex until he has a
2016          * chance to copy the RIF out into the outgoing packet, so that we
2017          * don't modify the entry while he's trying to copy it.  This is a
2018          * little ugly, but saves the extra bcopy.
2019          */
2020         ASSERT(mutex_owned(GLD_SR_MUTEX(macinfo)));
2021 
2022         *rhp = (struct gld_ri *)NULL;   /* start off clean (no RIF) */
2023 
2024         if (!((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_enabled) {
2025                 /* RDE is disabled -- use NULL or STE always */
2026                 if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->
2027                     rde_str_indicator_ste)
2028                         *rhp = &ri_ste_def; /* STE option */
2029                 return;
2030         }
2031 
2032         if (!(dhost[0] & 0x80)) {
2033                 /* individual address; Events 7 - 10 */
2034                 if ((snaphdr->control & 0xef) == 0xe3) {
2035                         /* TEST command, reset the route */
2036                         gld_reset_route(macinfo, q,
2037                             dhost, snaphdr->d_lsap, snaphdr->s_lsap);
2038                 }
2039                 gld_get_route(macinfo, q,
2040                     dhost, rhp, snaphdr->d_lsap, snaphdr->s_lsap);
2041         }
2042 
2043         if (*rhp == NULL) {
2044                 /*
2045                  * group address (Events 5 - 6),
2046                  * or no route available (Events 8 - 9):
2047                  * Need to send NSR or STE, as configured.
2048                  */
2049                 if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->
2050                     rde_str_indicator_ste)
2051                         *rhp = &ri_ste_def; /* STE option */
2052         }
2053 }
2054 
2055 /*
2056  * RCC send events 11 - 12
2057  *
2058  * At present we only handle the RQC ptype.
2059  *
2060  * We "know" that the only time we can get here is from the "unitdata"
2061  * routine, called at wsrv time.
2062  *
2063  * If we ever implement the RS ptype (Event 13), this may no longer be true!
2064  */
2065 static void
2066 gld_rde_pdu_req(gld_mac_info_t *macinfo, queue_t *q, uchar_t *dhost,
2067     struct gld_ri *rh, uchar_t dsap, uchar_t ssap, uchar_t ptype)
2068 {
2069         mblk_t *nmp;
2070         int nlen;
2071         struct tr_mac_frm_nori *nmh;
2072         struct gld_ri *nrh;
2073         struct llc_snap_hdr *nsnaphdr;
2074         struct rde_pdu *npdu;
2075         int srpresent = 0;
2076 
2077         /* if you change this to process other types, review all code below */
2078         ASSERT(ptype == RDE_RQC);
2079         ASSERT(rh == NULL);     /* RQC never uses SRF */
2080 
2081         nlen = sizeof (struct tr_mac_frm) + LLC_HDR1_LEN +
2082             sizeof (struct rde_pdu);
2083 
2084         if ((nmp = allocb(nlen, BPRI_MED)) == NULL)
2085                 return;
2086 
2087         nmp->b_rptr = nmp->b_wptr = DB_LIM(nmp);
2088 
2089         nmp->b_rptr -= sizeof (struct rde_pdu);
2090         npdu = (struct rde_pdu *)(nmp->b_rptr);
2091         npdu->rde_ver = 1;
2092         npdu->rde_ptype = ptype;
2093         mac_copy(dhost, &npdu->rde_target_mac, 6);
2094 
2095         /*
2096          * access the mac address without a mutex - take a risk -
2097          * to prevent mutex contention (BUG 4211361)
2098          */
2099         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
2100             &npdu->rde_orig_mac, 6);
2101         npdu->rde_target_sap = dsap;
2102         npdu->rde_orig_sap = ssap;
2103 
2104         nmp->b_rptr -= LLC_HDR1_LEN;
2105         nsnaphdr = (struct llc_snap_hdr *)(nmp->b_rptr);
2106         nsnaphdr->s_lsap = nsnaphdr->d_lsap = LSAP_RDE;
2107         nsnaphdr->control = CNTL_LLC_UI;
2108 
2109 #if 0   /* we don't need this for now */
2110         if (rh != NULL) {
2111                 /* send an SRF frame with specified RIF */
2112                 ASSERT(rh->len <= sizeof (struct gld_ri));
2113                 nmp->b_rptr -= rh->len;
2114                 nrh = (struct gld_ri *)(nmp->b_rptr);
2115                 bcopy(rh, nrh, rh->len);
2116                 ASSERT(nrh->rt == RT_SRF);
2117                 srpresent = 1;
2118         } else
2119 #endif
2120 
2121         /* Need to send NSR or STE, as configured.  */
2122         if (((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_str_indicator_ste) {
2123                 /* send an STE frame */
2124                 nmp->b_rptr -= 2;
2125                 nrh = (struct gld_ri *)(nmp->b_rptr);
2126                 nrh->len = 2;
2127                 nrh->rt = RT_STE;
2128                 nrh->dir = 0;
2129                 nrh->res = 0;
2130                 nrh->mtu = RT_MTU_MAX;
2131                 srpresent = 1;
2132         } /* else send an NSR frame */
2133 
2134         nmp->b_rptr -= sizeof (struct tr_mac_frm_nori);
2135         nmh = (struct tr_mac_frm_nori *)(nmp->b_rptr);
2136         nmh->tr_ac = 0x10;
2137         nmh->tr_fc = 0x40;
2138         mac_copy(dhost, nmh->tr_dhost, macinfo->gldm_addrlen);
2139         /*
2140          * access the mac address without a mutex - take a risk -
2141          * to prevent mutex contention  - BUG 4211361
2142          */
2143         mac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
2144             nmh->tr_shost, macinfo->gldm_addrlen);
2145 
2146         if (srpresent)
2147                 nmh->tr_shost[0] |= 0x80;
2148         else
2149                 nmh->tr_shost[0] &= ~0x80;
2150 
2151         /*
2152          * Packet assembled; send it.
2153          *
2154          * Since we own the SR_MUTEX, we don't want to take the maclock
2155          * mutex (since they are acquired in the opposite order on the
2156          * receive path, so deadlock could occur).  We could rearrange
2157          * the code in gld_get_route() and drop the SR_MUTEX around the
2158          * call to gld_rde_pdu_req(), but that's kind of ugly.  Rather,
2159          * we just refrain from calling gld_start() from here, and
2160          * instead just queue the packet for wsrv to send next.  Besides,
2161          * it's more important to get the packet we're working on out
2162          * quickly than this RQC.
2163          */
2164         (void) putbq(WR(q), nmp);
2165         qenable(WR(q));
2166 }
2167 
2168 /*
2169  * Route Determination Component (RDC)
2170  *
2171  * We do not implement separate routes for each SAP, as specified by
2172  * ISO 8802-2; instead we implement only one route per remote mac address.
2173  */
2174 static void
2175 gld_get_route(gld_mac_info_t *macinfo, queue_t *q, uchar_t *dhost,
2176     struct gld_ri **rhp, uchar_t dsap, uchar_t ssap)
2177 {
2178         struct srtab *sr;
2179         clock_t t = ddi_get_lbolt();
2180 
2181         ASSERT(mutex_owned(GLD_SR_MUTEX(macinfo)));
2182 
2183         sr = gld_sr_lookup_entry(macinfo, dhost);
2184 
2185         if (sr == NULL) {
2186                 /*
2187                  * we have no entry -- never heard of this address:
2188                  * create an empty entry and initiate RQC
2189                  */
2190                 sr = gld_sr_create_entry(macinfo, dhost);
2191                 gld_rde_pdu_req(macinfo, q, dhost, (struct gld_ri *)NULL,
2192                     dsap, ssap, RDE_RQC);
2193                 if (sr)
2194                         sr->sr_timer = t;
2195                 *rhp = NULL;            /* we have no route yet */
2196                 return;
2197         }
2198 
2199         /* we have an entry; see if we know a route yet */
2200 
2201         if (sr->sr_ri.len == 0) {
2202                 /* Have asked RQC, but no reply (yet) */
2203                 if (t - sr->sr_timer >
2204                     ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_timeout) {
2205                         /* RQR overdue, resend RQC */
2206                         gld_rde_pdu_req(macinfo, q, dhost,
2207                             (struct gld_ri *)NULL, dsap, ssap, RDE_RQC);
2208                         sr->sr_timer = t;
2209                 }
2210                 *rhp = NULL;            /* we have no route yet */
2211                 return;
2212         }
2213 
2214         /* we know a route, or it's local */
2215 
2216         /* if it might be stale, reset and get a new one */
2217         if (t - sr->sr_timer >
2218             ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->rde_timeout) {
2219                 gld_rde_pdu_req(macinfo, q, dhost,
2220                     (struct gld_ri *)NULL, dsap, ssap, RDE_RQC);
2221                 sr->sr_ri.len = 0;
2222                 sr->sr_timer = t;
2223                 *rhp = NULL;            /* we have no route */
2224                 return;
2225         }
2226 
2227         if (sr->sr_ri.len == 2) {
2228                 /* the remote site is on our local ring -- no route needed */
2229                 *rhp = NULL;
2230                 return;
2231         }
2232 
2233         *rhp = &sr->sr_ri;       /* we have a route, return it */
2234 }
2235 
2236 /*
2237  * zap the specified entry and reinitiate RQC
2238  */
2239 static void
2240 gld_reset_route(gld_mac_info_t *macinfo, queue_t *q,
2241     uchar_t *dhost, uchar_t dsap, uchar_t ssap)
2242 {
2243         struct srtab *sr;
2244 
2245         ASSERT(mutex_owned(GLD_SR_MUTEX(macinfo)));
2246 
2247         sr = gld_sr_create_entry(macinfo, dhost);
2248         gld_rde_pdu_req(macinfo, q, dhost, (struct gld_ri *)NULL,
2249             dsap, ssap, RDE_RQC);
2250         if (sr == NULL)
2251                 return;
2252 
2253         sr->sr_ri.len = 0;
2254         sr->sr_timer = ddi_get_lbolt();
2255 }
2256 
2257 /*
2258  * This routine is called when an RDE PDU is received from our peer.
2259  * If it is an RS (Route Selected) PDU, we adopt the specified route.
2260  * If it is an RQR (reply to our previous RQC), we evaluate the
2261  * specified route in comparison with our current known route, if any,
2262  * and we keep the "better" of the two routes.
2263  */
2264 static void
2265 gld_rde_pdu_ind(gld_mac_info_t *macinfo, struct gld_ri *rh, struct rde_pdu *pdu,
2266     int pdulen)
2267 {
2268         struct srtab *sr;
2269         uchar_t *otherhost;
2270 
2271         if (pdulen < sizeof (struct rde_pdu))
2272                 return;         /* Bad incoming PDU */
2273 
2274         if (pdu->rde_ptype == RDE_RQC)
2275                 return;                 /* ignore RQC */
2276 
2277         if (pdu->rde_ptype != RDE_RQR && pdu->rde_ptype != RDE_RS) {
2278 #ifdef GLD_DEBUG
2279                 if (gld_debug & GLDERRS)
2280                         cmn_err(CE_WARN, "gld: bogus RDE ptype 0x%x received",
2281                             pdu->rde_ptype);
2282 #endif
2283                 return;
2284         }
2285 
2286         if (rh == NULL) {
2287 #ifdef GLD_DEBUG
2288                 if (gld_debug & GLDERRS)
2289                         cmn_err(CE_WARN,
2290                             "gld: bogus NULL RIF, ptype 0x%x received",
2291                             pdu->rde_ptype);
2292 #endif
2293                 return;
2294         }
2295 
2296         ASSERT(rh->len >= 2);
2297         ASSERT(rh->len <= sizeof (struct gld_ri));
2298         ASSERT((rh->len & 1) == 0);
2299 
2300         if (pdu->rde_ptype == RDE_RQR) {
2301                 /* A reply to our RQC has his address as target mac */
2302                 otherhost = pdu->rde_target_mac;
2303         } else {
2304                 ASSERT(pdu->rde_ptype == RDE_RS);
2305                 /* An RS has his address as orig mac */
2306                 otherhost = pdu->rde_orig_mac;
2307         }
2308 
2309         mutex_enter(GLD_SR_MUTEX(macinfo));
2310 
2311         if ((sr = gld_sr_create_entry(macinfo, otherhost)) == NULL) {
2312                 mutex_exit(GLD_SR_MUTEX(macinfo));
2313                 return;         /* oh well, out of memory */
2314         }
2315 
2316         if (pdu->rde_ptype == RDE_RQR) {
2317                 /* see if new route is better than what we may already have */
2318                 if (sr->sr_ri.len != 0 &&
2319                     sr->sr_ri.len <= rh->len) {
2320                         mutex_exit(GLD_SR_MUTEX(macinfo));
2321                         return; /* we have one, and new one is no shorter */
2322                 }
2323         }
2324 
2325         /* adopt the new route */
2326         bcopy((caddr_t)rh, (caddr_t)&sr->sr_ri, rh->len); /* copy incom RIF */
2327         sr->sr_ri.rt = RT_SRF;       /* make it a clean SRF */
2328         sr->sr_ri.dir ^= 1;  /* reverse direction */
2329         sr->sr_timer = ddi_get_lbolt();
2330 
2331         mutex_exit(GLD_SR_MUTEX(macinfo));
2332 }
2333 
2334 /*
2335  * This routine is called when a packet with a RIF is received.  Our
2336  * policy is to adopt the route.
2337  */
2338 /* ARGSUSED3 */
2339 static void
2340 gld_rif_ind(gld_mac_info_t *macinfo, struct gld_ri *rh, uchar_t *shost,
2341     uchar_t ssap, uchar_t dsap)
2342 {
2343         struct srtab *sr;
2344 
2345         ASSERT(rh != NULL);             /* ensure RIF */
2346         ASSERT((rh->rt & 0x04) == 0);    /* ensure SRF */
2347         ASSERT(rh->len >= 2);
2348         ASSERT(rh->len <= sizeof (struct gld_ri));
2349         ASSERT((rh->len & 1) == 0);
2350 
2351         mutex_enter(GLD_SR_MUTEX(macinfo));
2352 
2353         if ((sr = gld_sr_create_entry(macinfo, shost)) == NULL) {
2354                 mutex_exit(GLD_SR_MUTEX(macinfo));
2355                 return;         /* oh well, out of memory */
2356         }
2357 
2358         /* we have an entry; fill it in */
2359         bcopy((caddr_t)rh, (caddr_t)&sr->sr_ri, rh->len); /* copy incom RIF */
2360         sr->sr_ri.rt = RT_SRF;       /* make it a clean SRF */
2361         sr->sr_ri.dir ^= 1;  /* reverse direction */
2362         sr->sr_timer = ddi_get_lbolt();
2363 
2364         mutex_exit(GLD_SR_MUTEX(macinfo));
2365 }
2366 
2367 static struct srtab **
2368 gld_sr_hash(struct srtab **sr_hash_tbl, uchar_t *addr, int addr_length)
2369 {
2370         uint_t hashval = 0;
2371 
2372         while (--addr_length >= 0)
2373                 hashval ^= *addr++;
2374 
2375         return (&sr_hash_tbl[hashval % SR_HASH_SIZE]);
2376 }
2377 
2378 static struct srtab *
2379 gld_sr_lookup_entry(gld_mac_info_t *macinfo, uchar_t *macaddr)
2380 {
2381         struct srtab *sr;
2382 
2383         ASSERT(mutex_owned(GLD_SR_MUTEX(macinfo)));
2384 
2385         for (sr = *gld_sr_hash(GLD_SR_HASH(macinfo), macaddr,
2386             macinfo->gldm_addrlen); sr; sr = sr->sr_next)
2387                 if (mac_eq(macaddr, sr->sr_mac, macinfo->gldm_addrlen))
2388                         return (sr);
2389 
2390         return ((struct srtab *)0);
2391 }
2392 
2393 static struct srtab *
2394 gld_sr_create_entry(gld_mac_info_t *macinfo, uchar_t *macaddr)
2395 {
2396         struct srtab *sr;
2397         struct srtab **srp;
2398 
2399         ASSERT(!(macaddr[0] & 0x80));       /* no group addresses here */
2400         ASSERT(mutex_owned(GLD_SR_MUTEX(macinfo)));
2401 
2402         srp = gld_sr_hash(GLD_SR_HASH(macinfo), macaddr, macinfo->gldm_addrlen);
2403 
2404         for (sr = *srp; sr; sr = sr->sr_next)
2405                 if (mac_eq(macaddr, sr->sr_mac, macinfo->gldm_addrlen))
2406                         return (sr);
2407 
2408         if (!(sr = kmem_zalloc(sizeof (struct srtab), KM_NOSLEEP))) {
2409 #ifdef GLD_DEBUG
2410                 if (gld_debug & GLDERRS)
2411                         cmn_err(CE_WARN,
2412                             "gld: gld_sr_create_entry kmem_alloc failed");
2413 #endif
2414                 return ((struct srtab *)0);
2415         }
2416 
2417         bcopy((caddr_t)macaddr, (caddr_t)sr->sr_mac, macinfo->gldm_addrlen);
2418 
2419         sr->sr_next = *srp;
2420         *srp = sr;
2421         return (sr);
2422 }
2423 
2424 static void
2425 gld_sr_clear(gld_mac_info_t *macinfo)
2426 {
2427         int i;
2428         struct srtab **sr_hash_tbl = GLD_SR_HASH(macinfo);
2429         struct srtab **srp, *sr;
2430 
2431         /*
2432          * Walk through the table, deleting all entries.
2433          *
2434          * Only called from uninit, so don't need the mutex.
2435          */
2436         for (i = 0; i < SR_HASH_SIZE; i++) {
2437                 for (srp = &sr_hash_tbl[i]; (sr = *srp) != NULL; ) {
2438                         *srp = sr->sr_next;
2439                         kmem_free((char *)sr, sizeof (struct srtab));
2440                 }
2441         }
2442 }
2443 
2444 #ifdef  DEBUG
2445 void
2446 gld_sr_dump(gld_mac_info_t *macinfo)
2447 {
2448         int i, j;
2449         struct srtab **sr_hash_tbl;
2450         struct srtab *sr;
2451 
2452         sr_hash_tbl = GLD_SR_HASH(macinfo);
2453         if (sr_hash_tbl == NULL)
2454                 return;
2455 
2456         mutex_enter(GLD_SR_MUTEX(macinfo));
2457 
2458         /*
2459          * Walk through the table, printing all entries
2460          */
2461         cmn_err(CE_NOTE, "GLD Source Routing Table (0x%p):", (void *)macinfo);
2462         cmn_err(CE_CONT, "Addr len,rt,dir,mtu,res rng,brg0 rng,brg1...\n");
2463         for (i = 0; i < SR_HASH_SIZE; i++) {
2464                 for (sr = sr_hash_tbl[i]; sr; sr = sr->sr_next) {
2465                         cmn_err(CE_CONT,
2466                             "%x:%x:%x:%x:%x:%x %d,%x,%x,%x,%x ",
2467                             sr->sr_mac[0], sr->sr_mac[1], sr->sr_mac[2],
2468                             sr->sr_mac[3], sr->sr_mac[4], sr->sr_mac[5],
2469                             sr->sr_ri.len, sr->sr_ri.rt, sr->sr_ri.dir,
2470                             sr->sr_ri.mtu, sr->sr_ri.res);
2471                         if (sr->sr_ri.len)
2472                                 for (j = 0; j < (sr->sr_ri.len - 2) / 2; j++)
2473                                         cmn_err(CE_CONT, "%x ",
2474                                             REF_NET_USHORT(*(unsigned short *)
2475                                             &sr->sr_ri.rd[j]));
2476                         cmn_err(CE_CONT, "\n");
2477                 }
2478         }
2479 
2480         mutex_exit(GLD_SR_MUTEX(macinfo));
2481 }
2482 #endif