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_usectohz(1000000 * 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