xref: /titanic_51/usr/src/uts/common/io/gld.c (revision 1a5e258f5471356ca102c7176637cdce45bac147)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * gld - Generic LAN Driver Version 2, PSARC/1997/382
28  *
29  * This is a utility module that provides generic facilities for
30  * LAN	drivers.  The DLPI protocol and most STREAMS interfaces
31  * are handled here.
32  *
33  * It no longer provides compatibility with drivers
34  * implemented according to the GLD v0 documentation published
35  * in 1993. (See PSARC 2003/728)
36  */
37 
38 
39 #include <sys/types.h>
40 #include <sys/errno.h>
41 #include <sys/stropts.h>
42 #include <sys/stream.h>
43 #include <sys/kmem.h>
44 #include <sys/stat.h>
45 #include <sys/modctl.h>
46 #include <sys/kstat.h>
47 #include <sys/debug.h>
48 #include <sys/note.h>
49 #include <sys/sysmacros.h>
50 
51 #include <sys/byteorder.h>
52 #include <sys/strsun.h>
53 #include <sys/strsubr.h>
54 #include <sys/dlpi.h>
55 #include <sys/pattr.h>
56 #include <sys/ethernet.h>
57 #include <sys/ib/clients/ibd/ibd.h>
58 #include <sys/policy.h>
59 #include <sys/atomic.h>
60 
61 #include <sys/multidata.h>
62 #include <sys/gld.h>
63 #include <sys/gldpriv.h>
64 
65 #include <sys/ddi.h>
66 #include <sys/sunddi.h>
67 
68 /*
69  * Macros to increment statistics.
70  */
71 
72 /*
73  * Increase kstats. Note this operation is not atomic. It can be used when
74  * GLDM_LOCK_HELD_WRITE(macinfo).
75  */
76 #define	BUMP(stats, vstats, stat, delta)	do {			\
77 	((stats)->stat) += (delta);					\
78 	_NOTE(CONSTANTCONDITION)					\
79 	if ((vstats) != NULL)						\
80 		((struct gld_stats *)(vstats))->stat += (delta);	\
81 	_NOTE(CONSTANTCONDITION)					\
82 } while (0)
83 
84 #define	ATOMIC_BUMP_STAT(stat, delta)	do {			\
85 	_NOTE(CONSTANTCONDITION)				\
86 	if (sizeof ((stat)) == sizeof (uint32_t)) {		\
87 		atomic_add_32((uint32_t *)&(stat), (delta));	\
88 	_NOTE(CONSTANTCONDITION)				\
89 	} else if (sizeof ((stat)) == sizeof (uint64_t)) {	\
90 		atomic_add_64((uint64_t *)&(stat), (delta));	\
91 	}							\
92 	_NOTE(CONSTANTCONDITION)				\
93 } while (0)
94 
95 #define	ATOMIC_BUMP(stats, vstats, stat, delta)	do {			\
96 	ATOMIC_BUMP_STAT((stats)->stat, (delta));			\
97 	_NOTE(CONSTANTCONDITION)					\
98 	if ((vstats) != NULL) {						\
99 		ATOMIC_BUMP_STAT(((struct gld_stats *)(vstats))->stat,	\
100 		    (delta));						\
101 	}								\
102 	_NOTE(CONSTANTCONDITION)					\
103 } while (0)
104 
105 #define	UPDATE_STATS(stats, vstats, pktinfo, delta) {			\
106 	if ((pktinfo).isBroadcast) {					\
107 		ATOMIC_BUMP((stats), (vstats),				\
108 		    glds_brdcstxmt, (delta));				\
109 	} else if ((pktinfo).isMulticast) {				\
110 		ATOMIC_BUMP((stats), (vstats), glds_multixmt, (delta));	\
111 	}								\
112 	ATOMIC_BUMP((stats), (vstats), glds_bytexmt64,			\
113 	    ((pktinfo).pktLen));					\
114 	ATOMIC_BUMP((stats), (vstats), glds_pktxmt64, (delta));		\
115 }
116 
117 #ifdef GLD_DEBUG
118 int gld_debug = GLDERRS;
119 #endif
120 
121 /* called from gld_register */
122 static int gld_initstats(gld_mac_info_t *);
123 
124 /* called from kstat mechanism, and from wsrv's get_statistics */
125 static int gld_update_kstat(kstat_t *, int);
126 
127 /* statistics for additional vlans */
128 static int gld_init_vlan_stats(gld_vlan_t *);
129 static int gld_update_vlan_kstat(kstat_t *, int);
130 
131 /* called from gld_getinfo */
132 static dev_info_t *gld_finddevinfo(dev_t);
133 
134 /* called from wput, wsrv, unidata, and v0_sched to send a packet */
135 /* also from the source routing stuff for sending RDE protocol packets */
136 static int gld_start(queue_t *, mblk_t *, int, uint32_t);
137 static int gld_start_mdt(queue_t *, mblk_t *, int);
138 
139 /* called from gld_start[_mdt] to loopback packet(s) in promiscuous mode */
140 static void gld_precv(gld_mac_info_t *, mblk_t *, uint32_t, struct gld_stats *);
141 static void gld_precv_mdt(gld_mac_info_t *, gld_vlan_t *, mblk_t *,
142     pdesc_t *, pktinfo_t *);
143 
144 /* receive group: called from gld_recv and gld_precv* with maclock held */
145 static void gld_sendup(gld_mac_info_t *, pktinfo_t *, mblk_t *,
146     int (*)());
147 static int gld_accept(gld_t *, pktinfo_t *);
148 static int gld_mcmatch(gld_t *, pktinfo_t *);
149 static int gld_multicast(unsigned char *, gld_t *);
150 static int gld_paccept(gld_t *, pktinfo_t *);
151 static void gld_passon(gld_t *, mblk_t *, pktinfo_t *,
152     void (*)(queue_t *, mblk_t *));
153 static mblk_t *gld_addudind(gld_t *, mblk_t *, pktinfo_t *, boolean_t);
154 
155 /* wsrv group: called from wsrv, single threaded per queue */
156 static int gld_ioctl(queue_t *, mblk_t *);
157 static void gld_fastpath(gld_t *, queue_t *, mblk_t *);
158 static int gld_cmds(queue_t *, mblk_t *);
159 static mblk_t *gld_bindack(queue_t *, mblk_t *);
160 static int gld_notify_req(queue_t *, mblk_t *);
161 static int gld_udqos(queue_t *, mblk_t *);
162 static int gld_bind(queue_t *, mblk_t *);
163 static int gld_unbind(queue_t *, mblk_t *);
164 static int gld_inforeq(queue_t *, mblk_t *);
165 static int gld_unitdata(queue_t *, mblk_t *);
166 static int gldattach(queue_t *, mblk_t *);
167 static int gldunattach(queue_t *, mblk_t *);
168 static int gld_enable_multi(queue_t *, mblk_t *);
169 static int gld_disable_multi(queue_t *, mblk_t *);
170 static void gld_send_disable_multi(gld_mac_info_t *, gld_mcast_t *);
171 static int gld_promisc(queue_t *, mblk_t *, t_uscalar_t, boolean_t);
172 static int gld_physaddr(queue_t *, mblk_t *);
173 static int gld_setaddr(queue_t *, mblk_t *);
174 static int gld_get_statistics(queue_t *, mblk_t *);
175 static int gld_cap(queue_t *, mblk_t *);
176 static int gld_cap_ack(queue_t *, mblk_t *);
177 static int gld_cap_enable(queue_t *, mblk_t *);
178 
179 /* misc utilities, some requiring various mutexes held */
180 static int gld_start_mac(gld_mac_info_t *);
181 static void gld_stop_mac(gld_mac_info_t *);
182 static void gld_set_ipq(gld_t *);
183 static void gld_flushqueue(queue_t *);
184 static glddev_t *gld_devlookup(int);
185 static int gld_findminor(glddev_t *);
186 static void gldinsque(void *, void *);
187 static void gldremque(void *);
188 void gld_bitrevcopy(caddr_t, caddr_t, size_t);
189 void gld_bitreverse(uchar_t *, size_t);
190 char *gld_macaddr_sprintf(char *, unsigned char *, int);
191 static gld_vlan_t *gld_add_vlan(gld_mac_info_t *, uint32_t vid);
192 static void gld_rem_vlan(gld_vlan_t *);
193 gld_vlan_t *gld_find_vlan(gld_mac_info_t *, uint32_t);
194 gld_vlan_t *gld_get_vlan(gld_mac_info_t *, uint32_t);
195 
196 #ifdef GLD_DEBUG
197 static void gld_check_assertions(void);
198 extern void gld_sr_dump(gld_mac_info_t *);
199 #endif
200 
201 /*
202  * Allocate and zero-out "number" structures each of type "structure" in
203  * kernel memory.
204  */
205 #define	GLD_GETSTRUCT(structure, number)   \
206 	(kmem_zalloc((uint_t)(sizeof (structure) * (number)), KM_NOSLEEP))
207 
208 #define	abs(a) ((a) < 0 ? -(a) : a)
209 
210 uint32_t gld_global_options = GLD_OPT_NO_ETHRXSNAP;
211 
212 /*
213  * The device is of DL_ETHER type and is able to support VLAN by itself.
214  */
215 #define	VLAN_CAPABLE(macinfo) \
216 	((macinfo)->gldm_type == DL_ETHER && \
217 	(macinfo)->gldm_send_tagged != NULL)
218 
219 /*
220  * The set of notifications generatable by GLD itself, the additional
221  * set that can be generated if the MAC driver provide the link-state
222  * tracking callback capability, and the set supported by the GLD
223  * notification code below.
224  *
225  * PLEASE keep these in sync with what the code actually does!
226  */
227 static const uint32_t gld_internal_notes =	DL_NOTE_PROMISC_ON_PHYS |
228 						DL_NOTE_PROMISC_OFF_PHYS |
229 						DL_NOTE_PHYS_ADDR;
230 static const uint32_t gld_linkstate_notes =	DL_NOTE_LINK_DOWN |
231 						DL_NOTE_LINK_UP |
232 						DL_NOTE_SPEED;
233 static const uint32_t gld_supported_notes =	DL_NOTE_PROMISC_ON_PHYS |
234 						DL_NOTE_PROMISC_OFF_PHYS |
235 						DL_NOTE_PHYS_ADDR |
236 						DL_NOTE_LINK_DOWN |
237 						DL_NOTE_LINK_UP |
238 						DL_NOTE_SPEED;
239 
240 /* Media must correspond to #defines in gld.h */
241 static char *gld_media[] = {
242 	"unknown",	/* GLDM_UNKNOWN - driver cannot determine media */
243 	"aui",		/* GLDM_AUI */
244 	"bnc",		/* GLDM_BNC */
245 	"twpair",	/* GLDM_TP */
246 	"fiber",	/* GLDM_FIBER */
247 	"100baseT",	/* GLDM_100BT */
248 	"100vgAnyLan",	/* GLDM_VGANYLAN */
249 	"10baseT",	/* GLDM_10BT */
250 	"ring4",	/* GLDM_RING4 */
251 	"ring16",	/* GLDM_RING16 */
252 	"PHY/MII",	/* GLDM_PHYMII */
253 	"100baseTX",	/* GLDM_100BTX */
254 	"100baseT4",	/* GLDM_100BT4 */
255 	"unknown",	/* skip */
256 	"ipib",		/* GLDM_IB */
257 };
258 
259 /* Must correspond to #defines in gld.h */
260 static char *gld_duplex[] = {
261 	"unknown",	/* GLD_DUPLEX_UNKNOWN - not known or not applicable */
262 	"half",		/* GLD_DUPLEX_HALF */
263 	"full"		/* GLD_DUPLEX_FULL */
264 };
265 
266 /*
267  * Interface types currently supported by GLD.
268  * If you add new types, you must check all "XXX" strings in the GLD source
269  * for implementation issues that may affect the support of your new type.
270  * In particular, any type with gldm_addrlen > 6, or gldm_saplen != -2, will
271  * require generalizing this GLD source to handle the new cases.  In other
272  * words there are assumptions built into the code in a few places that must
273  * be fixed.  Be sure to turn on DEBUG/ASSERT code when testing a new type.
274  */
275 static gld_interface_t interfaces[] = {
276 
277 	/* Ethernet Bus */
278 	{
279 		DL_ETHER,
280 		(uint_t)-1,
281 		sizeof (struct ether_header),
282 		gld_interpret_ether,
283 		NULL,
284 		gld_fastpath_ether,
285 		gld_unitdata_ether,
286 		gld_init_ether,
287 		gld_uninit_ether,
288 		"ether"
289 	},
290 
291 	/* Fiber Distributed data interface */
292 	{
293 		DL_FDDI,
294 		4352,
295 		sizeof (struct fddi_mac_frm),
296 		gld_interpret_fddi,
297 		NULL,
298 		gld_fastpath_fddi,
299 		gld_unitdata_fddi,
300 		gld_init_fddi,
301 		gld_uninit_fddi,
302 		"fddi"
303 	},
304 
305 	/* Token Ring interface */
306 	{
307 		DL_TPR,
308 		17914,
309 		-1,			/* variable header size */
310 		gld_interpret_tr,
311 		NULL,
312 		gld_fastpath_tr,
313 		gld_unitdata_tr,
314 		gld_init_tr,
315 		gld_uninit_tr,
316 		"tpr"
317 	},
318 
319 	/* Infiniband */
320 	{
321 		DL_IB,
322 		4092,
323 		sizeof (struct ipoib_header),
324 		gld_interpret_ib,
325 		gld_interpret_mdt_ib,
326 		gld_fastpath_ib,
327 		gld_unitdata_ib,
328 		gld_init_ib,
329 		gld_uninit_ib,
330 		"ipib"
331 	},
332 };
333 
334 /*
335  * bit reversal lookup table.
336  */
337 static	uchar_t bit_rev[] = {
338 	0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50, 0xd0,
339 	0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
340 	0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04, 0x84, 0x44, 0xc4,
341 	0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
342 	0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec, 0x1c, 0x9c, 0x5c, 0xdc,
343 	0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
344 	0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca,
345 	0x2a, 0xaa, 0x6a, 0xea, 0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
346 	0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6,
347 	0x36, 0xb6, 0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
348 	0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
349 	0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
350 	0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99, 0x59, 0xd9,
351 	0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
352 	0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5, 0x0d, 0x8d, 0x4d, 0xcd,
353 	0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
354 	0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3,
355 	0x33, 0xb3, 0x73, 0xf3, 0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
356 	0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7,
357 	0x27, 0xa7, 0x67, 0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
358 	0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf,
359 	0x3f, 0xbf, 0x7f, 0xff,
360 };
361 
362 /*
363  * User priorities, mapped from b_band.
364  */
365 static uint32_t user_priority[] = {
366 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
367 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
368 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
369 	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
370 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
371 	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
372 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
373 	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
374 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
375 	4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
376 	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
377 	5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
378 	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
379 	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
380 	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
381 	7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
382 };
383 
384 #define	UPRI(gld, band)	((band != 0) ? user_priority[(band)] : (gld)->gld_upri)
385 
386 static struct glddevice gld_device_list;  /* Per-system root of GLD tables */
387 
388 /*
389  * Module linkage information for the kernel.
390  */
391 
392 static struct modldrv modlmisc = {
393 	&mod_miscops,		/* Type of module - a utility provider */
394 	"Generic LAN Driver (" GLD_VERSION_STRING ")"
395 #ifdef GLD_DEBUG
396 	" DEBUG"
397 #endif
398 };
399 
400 static struct modlinkage modlinkage = {
401 	MODREV_1, &modlmisc, NULL
402 };
403 
404 int
405 _init(void)
406 {
407 	int e;
408 
409 	/* initialize gld_device_list mutex */
410 	mutex_init(&gld_device_list.gld_devlock, NULL, MUTEX_DRIVER, NULL);
411 
412 	/* initialize device driver (per-major) list */
413 	gld_device_list.gld_next =
414 	    gld_device_list.gld_prev = &gld_device_list;
415 
416 	if ((e = mod_install(&modlinkage)) != 0)
417 		mutex_destroy(&gld_device_list.gld_devlock);
418 
419 	return (e);
420 }
421 
422 int
423 _fini(void)
424 {
425 	int e;
426 
427 	if ((e = mod_remove(&modlinkage)) != 0)
428 		return (e);
429 
430 	ASSERT(gld_device_list.gld_next ==
431 	    (glddev_t *)&gld_device_list.gld_next);
432 	ASSERT(gld_device_list.gld_prev ==
433 	    (glddev_t *)&gld_device_list.gld_next);
434 	mutex_destroy(&gld_device_list.gld_devlock);
435 
436 	return (e);
437 }
438 
439 int
440 _info(struct modinfo *modinfop)
441 {
442 	return (mod_info(&modlinkage, modinfop));
443 }
444 
445 /*
446  * GLD service routines
447  */
448 
449 /* So this gld binary maybe can be forward compatible with future v2 drivers */
450 #define	GLD_MAC_RESERVED (16 * sizeof (caddr_t))
451 
452 /*ARGSUSED*/
453 gld_mac_info_t *
454 gld_mac_alloc(dev_info_t *devinfo)
455 {
456 	gld_mac_info_t *macinfo;
457 
458 	macinfo = kmem_zalloc(sizeof (gld_mac_info_t) + GLD_MAC_RESERVED,
459 	    KM_SLEEP);
460 
461 	/*
462 	 * The setting of gldm_driver_version will not be documented or allowed
463 	 * until a future release.
464 	 */
465 	macinfo->gldm_driver_version = GLD_VERSION_200;
466 
467 	/*
468 	 * GLD's version.  This also is undocumented for now, but will be
469 	 * available if needed in the future.
470 	 */
471 	macinfo->gldm_GLD_version = GLD_VERSION;
472 
473 	return (macinfo);
474 }
475 
476 /*
477  * gld_mac_free must be called after the driver has removed interrupts
478  * and completely stopped calling gld_recv() and gld_sched().  At that
479  * point the interrupt routine is guaranteed by the system to have been
480  * exited and the maclock is no longer needed.  Of course, it is
481  * expected (required) that (assuming gld_register() succeeded),
482  * gld_unregister() was called before gld_mac_free().
483  */
484 void
485 gld_mac_free(gld_mac_info_t *macinfo)
486 {
487 	ASSERT(macinfo);
488 	ASSERT(macinfo->gldm_GLD_version == GLD_VERSION);
489 
490 	/*
491 	 * Assert that if we made it through gld_register, then we must
492 	 * have unregistered.
493 	 */
494 	ASSERT(!GLDM_LOCK_INITED(macinfo) ||
495 	    (macinfo->gldm_GLD_flags & GLD_UNREGISTERED));
496 
497 	GLDM_LOCK_DESTROY(macinfo);
498 
499 	kmem_free(macinfo, sizeof (gld_mac_info_t) + GLD_MAC_RESERVED);
500 }
501 
502 /*
503  * gld_register -- called once per device instance (PPA)
504  *
505  * During its attach routine, a real device driver will register with GLD
506  * so that later opens and dl_attach_reqs will work.  The arguments are the
507  * devinfo pointer, the device name, and a macinfo structure describing the
508  * physical device instance.
509  */
510 int
511 gld_register(dev_info_t *devinfo, char *devname, gld_mac_info_t *macinfo)
512 {
513 	int mediatype;
514 	int major = ddi_name_to_major(devname), i;
515 	glddev_t *glddev;
516 	gld_mac_pvt_t *mac_pvt;
517 	char minordev[32];
518 	char pbuf[3*GLD_MAX_ADDRLEN];
519 	gld_interface_t *ifp;
520 
521 	ASSERT(devinfo != NULL);
522 	ASSERT(macinfo != NULL);
523 
524 	if (macinfo->gldm_driver_version != GLD_VERSION)
525 		return (DDI_FAILURE);
526 
527 	mediatype = macinfo->gldm_type;
528 
529 	/*
530 	 * Entry points should be ready for us.
531 	 * ioctl is optional.
532 	 * set_multicast and get_stats are optional in v0.
533 	 * intr is only required if you add an interrupt.
534 	 */
535 	ASSERT(macinfo->gldm_reset != NULL);
536 	ASSERT(macinfo->gldm_start != NULL);
537 	ASSERT(macinfo->gldm_stop != NULL);
538 	ASSERT(macinfo->gldm_set_mac_addr != NULL);
539 	ASSERT(macinfo->gldm_set_promiscuous != NULL);
540 	ASSERT(macinfo->gldm_send != NULL);
541 
542 	ASSERT(macinfo->gldm_maxpkt >= macinfo->gldm_minpkt);
543 	ASSERT(macinfo->gldm_GLD_version == GLD_VERSION);
544 	ASSERT(macinfo->gldm_broadcast_addr != NULL);
545 	ASSERT(macinfo->gldm_vendor_addr != NULL);
546 	ASSERT(macinfo->gldm_ident != NULL);
547 
548 	if (macinfo->gldm_addrlen > GLD_MAX_ADDRLEN) {
549 		cmn_err(CE_WARN, "GLD: %s driver gldm_addrlen %d > %d not sup"
550 		    "ported", devname, macinfo->gldm_addrlen, GLD_MAX_ADDRLEN);
551 		return (DDI_FAILURE);
552 	}
553 
554 	/*
555 	 * GLD only functions properly with saplen == -2
556 	 */
557 	if (macinfo->gldm_saplen != -2) {
558 		cmn_err(CE_WARN, "GLD: %s driver gldm_saplen %d != -2 "
559 		    "not supported", devname, macinfo->gldm_saplen);
560 		return (DDI_FAILURE);
561 	}
562 
563 	/* see gld_rsrv() */
564 	if (ddi_getprop(DDI_DEV_T_NONE, devinfo, 0, "fast_recv", 0))
565 		macinfo->gldm_options |= GLDOPT_FAST_RECV;
566 
567 	mutex_enter(&gld_device_list.gld_devlock);
568 	glddev = gld_devlookup(major);
569 
570 	/*
571 	 *  Allocate per-driver (major) data structure if necessary
572 	 */
573 	if (glddev == NULL) {
574 		/* first occurrence of this device name (major number) */
575 		glddev = GLD_GETSTRUCT(glddev_t, 1);
576 		if (glddev == NULL) {
577 			mutex_exit(&gld_device_list.gld_devlock);
578 			return (DDI_FAILURE);
579 		}
580 		(void) strncpy(glddev->gld_name, devname,
581 		    sizeof (glddev->gld_name) - 1);
582 		glddev->gld_major = major;
583 		glddev->gld_nextminor = GLD_MIN_CLONE_MINOR;
584 		glddev->gld_mac_next = glddev->gld_mac_prev =
585 		    (gld_mac_info_t *)&glddev->gld_mac_next;
586 		glddev->gld_str_next = glddev->gld_str_prev =
587 		    (gld_t *)&glddev->gld_str_next;
588 		mutex_init(&glddev->gld_devlock, NULL, MUTEX_DRIVER, NULL);
589 
590 		/* allow increase of number of supported multicast addrs */
591 		glddev->gld_multisize = ddi_getprop(DDI_DEV_T_NONE,
592 		    devinfo, 0, "multisize", GLD_MAX_MULTICAST);
593 
594 		/*
595 		 * Optionally restrict DLPI provider style
596 		 *
597 		 * -1 - don't create style 1 nodes
598 		 * -2 - don't create style 2 nodes
599 		 */
600 		glddev->gld_styles = ddi_getprop(DDI_DEV_T_NONE, devinfo, 0,
601 		    "gld-provider-styles", 0);
602 
603 		/* Stuff that's needed before any PPA gets attached */
604 		glddev->gld_type = macinfo->gldm_type;
605 		glddev->gld_minsdu = macinfo->gldm_minpkt;
606 		glddev->gld_saplen = macinfo->gldm_saplen;
607 		glddev->gld_addrlen = macinfo->gldm_addrlen;
608 		glddev->gld_broadcast = kmem_zalloc(macinfo->gldm_addrlen,
609 		    KM_SLEEP);
610 		bcopy(macinfo->gldm_broadcast_addr,
611 		    glddev->gld_broadcast, macinfo->gldm_addrlen);
612 		glddev->gld_maxsdu = macinfo->gldm_maxpkt;
613 		gldinsque(glddev, gld_device_list.gld_prev);
614 	}
615 	glddev->gld_ndevice++;
616 	/* Now glddev can't go away until we unregister this mac (or fail) */
617 	mutex_exit(&gld_device_list.gld_devlock);
618 
619 	/*
620 	 *  Per-instance initialization
621 	 */
622 
623 	/*
624 	 * Initialize per-mac structure that is private to GLD.
625 	 * Set up interface pointer. These are device class specific pointers
626 	 * used to handle FDDI/TR/ETHER/IPoIB specific packets.
627 	 */
628 	for (i = 0; i < sizeof (interfaces)/sizeof (*interfaces); i++) {
629 		if (mediatype != interfaces[i].mac_type)
630 			continue;
631 
632 		macinfo->gldm_mac_pvt = kmem_zalloc(sizeof (gld_mac_pvt_t),
633 		    KM_SLEEP);
634 		((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep = ifp =
635 		    &interfaces[i];
636 		break;
637 	}
638 
639 	if (ifp == NULL) {
640 		cmn_err(CE_WARN, "GLD: this version does not support %s driver "
641 		    "of type %d", devname, mediatype);
642 		goto failure;
643 	}
644 
645 	/*
646 	 * Driver can only register MTU within legal media range.
647 	 */
648 	if (macinfo->gldm_maxpkt > ifp->mtu_size) {
649 		cmn_err(CE_WARN, "GLD: oversize MTU is specified by driver %s",
650 		    devname);
651 		goto failure;
652 	}
653 
654 	/*
655 	 * Correct margin size if it is not set.
656 	 */
657 	if (VLAN_CAPABLE(macinfo) && (macinfo->gldm_margin == 0))
658 		macinfo->gldm_margin = VTAG_SIZE;
659 
660 	/*
661 	 * For now, only Infiniband drivers can use MDT. Do not add
662 	 * support for Ethernet, FDDI or TR.
663 	 */
664 	if (macinfo->gldm_mdt_pre != NULL) {
665 		if (mediatype != DL_IB) {
666 			cmn_err(CE_WARN, "GLD: MDT not supported for %s "
667 			    "driver of type %d", devname, mediatype);
668 			goto failure;
669 		}
670 
671 		/*
672 		 * Validate entry points.
673 		 */
674 		if ((macinfo->gldm_mdt_send == NULL) ||
675 		    (macinfo->gldm_mdt_post == NULL)) {
676 			cmn_err(CE_WARN, "GLD: invalid MDT entry points for "
677 			    "%s driver of type %d", devname, mediatype);
678 			goto failure;
679 		}
680 		macinfo->gldm_options |= GLDOPT_MDT;
681 	}
682 
683 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
684 	mac_pvt->major_dev = glddev;
685 
686 	mac_pvt->curr_macaddr = kmem_zalloc(macinfo->gldm_addrlen, KM_SLEEP);
687 	/*
688 	 * XXX Do bit-reversed devices store gldm_vendor in canonical
689 	 * format or in wire format?  Also gldm_broadcast.  For now
690 	 * we are assuming canonical, but I'm not sure that makes the
691 	 * most sense for ease of driver implementation.
692 	 */
693 	bcopy(macinfo->gldm_vendor_addr, mac_pvt->curr_macaddr,
694 	    macinfo->gldm_addrlen);
695 	mac_pvt->statistics = kmem_zalloc(sizeof (struct gld_stats), KM_SLEEP);
696 
697 	/*
698 	 * The available set of notifications is those generatable by GLD
699 	 * itself, plus those corresponding to the capabilities of the MAC
700 	 * driver, intersected with those supported by gld_notify_ind() above.
701 	 */
702 	mac_pvt->notifications = gld_internal_notes;
703 	if (macinfo->gldm_capabilities & GLD_CAP_LINKSTATE)
704 		mac_pvt->notifications |= gld_linkstate_notes;
705 	mac_pvt->notifications &= gld_supported_notes;
706 
707 	GLDM_LOCK_INIT(macinfo);
708 
709 	ddi_set_driver_private(devinfo, macinfo);
710 
711 	/*
712 	 * Now atomically get a PPA and put ourselves on the mac list.
713 	 */
714 	mutex_enter(&glddev->gld_devlock);
715 
716 #ifdef DEBUG
717 	if (macinfo->gldm_ppa != ddi_get_instance(devinfo))
718 		cmn_err(CE_WARN, "%s%d instance != ppa %d",
719 		    ddi_driver_name(devinfo), ddi_get_instance(devinfo),
720 		    macinfo->gldm_ppa);
721 #endif
722 
723 	/*
724 	 * Create style 2 node (gated by gld-provider-styles property).
725 	 *
726 	 * NOTE: When the CLONE_DEV flag is specified to
727 	 *	 ddi_create_minor_node() the minor number argument is
728 	 *	 immaterial. Opens of that node will go via the clone
729 	 *	 driver and gld_open() will always be passed a dev_t with
730 	 *	 minor of zero.
731 	 */
732 	if (glddev->gld_styles != -2) {
733 		if (ddi_create_minor_node(devinfo, glddev->gld_name, S_IFCHR,
734 		    0, DDI_NT_NET, CLONE_DEV) == DDI_FAILURE) {
735 			mutex_exit(&glddev->gld_devlock);
736 			goto late_failure;
737 		}
738 	}
739 
740 	/*
741 	 * Create style 1 node (gated by gld-provider-styles property)
742 	 */
743 	if (glddev->gld_styles != -1) {
744 		(void) sprintf(minordev, "%s%d", glddev->gld_name,
745 		    macinfo->gldm_ppa);
746 		if (ddi_create_minor_node(devinfo, minordev, S_IFCHR,
747 		    GLD_STYLE1_PPA_TO_MINOR(macinfo->gldm_ppa), DDI_NT_NET,
748 		    0) != DDI_SUCCESS) {
749 			mutex_exit(&glddev->gld_devlock);
750 			goto late_failure;
751 		}
752 	}
753 
754 	/* add ourselves to this major device's linked list of instances */
755 	gldinsque(macinfo, glddev->gld_mac_prev);
756 
757 	mutex_exit(&glddev->gld_devlock);
758 
759 	/*
760 	 * Unfortunately we need the ppa before we call gld_initstats();
761 	 * otherwise we would like to do this just above the mutex_enter
762 	 * above.  In which case we could have set MAC_READY inside the
763 	 * mutex and we wouldn't have needed to check it in open and
764 	 * DL_ATTACH.  We wouldn't like to do the initstats/kstat_create
765 	 * inside the mutex because it might get taken in our kstat_update
766 	 * routine and cause a deadlock with kstat_chain_lock.
767 	 */
768 
769 	/* gld_initstats() calls (*ifp->init)() */
770 	if (gld_initstats(macinfo) != GLD_SUCCESS) {
771 		mutex_enter(&glddev->gld_devlock);
772 		gldremque(macinfo);
773 		mutex_exit(&glddev->gld_devlock);
774 		goto late_failure;
775 	}
776 
777 	/*
778 	 * Need to indicate we are NOW ready to process interrupts;
779 	 * any interrupt before this is set is for someone else.
780 	 * This flag is also now used to tell open, et. al. that this
781 	 * mac is now fully ready and available for use.
782 	 */
783 	GLDM_LOCK(macinfo, RW_WRITER);
784 	macinfo->gldm_GLD_flags |= GLD_MAC_READY;
785 	GLDM_UNLOCK(macinfo);
786 
787 	/* log local ethernet address -- XXX not DDI compliant */
788 	if (macinfo->gldm_addrlen == sizeof (struct ether_addr))
789 		(void) localetheraddr(
790 		    (struct ether_addr *)macinfo->gldm_vendor_addr, NULL);
791 
792 	/* now put announcement into the message buffer */
793 	cmn_err(CE_CONT, "!%s%d: %s: type \"%s\" mac address %s\n",
794 	    glddev->gld_name,
795 	    macinfo->gldm_ppa, macinfo->gldm_ident,
796 	    mac_pvt->interfacep->mac_string,
797 	    gld_macaddr_sprintf(pbuf, macinfo->gldm_vendor_addr,
798 	    macinfo->gldm_addrlen));
799 
800 	ddi_report_dev(devinfo);
801 	return (DDI_SUCCESS);
802 
803 late_failure:
804 	ddi_remove_minor_node(devinfo, NULL);
805 	GLDM_LOCK_DESTROY(macinfo);
806 	if (mac_pvt->curr_macaddr != NULL)
807 		kmem_free(mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
808 	if (mac_pvt->statistics != NULL)
809 		kmem_free(mac_pvt->statistics, sizeof (struct gld_stats));
810 	kmem_free(macinfo->gldm_mac_pvt, sizeof (gld_mac_pvt_t));
811 	macinfo->gldm_mac_pvt = NULL;
812 
813 failure:
814 	mutex_enter(&gld_device_list.gld_devlock);
815 	glddev->gld_ndevice--;
816 	/*
817 	 * Note that just because this goes to zero here does not necessarily
818 	 * mean that we were the one who added the glddev above.  It's
819 	 * possible that the first mac unattached while were were in here
820 	 * failing to attach the second mac.  But we're now the last.
821 	 */
822 	if (glddev->gld_ndevice == 0) {
823 		/* There should be no macinfos left */
824 		ASSERT(glddev->gld_mac_next ==
825 		    (gld_mac_info_t *)&glddev->gld_mac_next);
826 		ASSERT(glddev->gld_mac_prev ==
827 		    (gld_mac_info_t *)&glddev->gld_mac_next);
828 
829 		/*
830 		 * There should be no DL_UNATTACHED streams: the system
831 		 * should not have detached the "first" devinfo which has
832 		 * all the open style 2 streams.
833 		 *
834 		 * XXX This is not clear.  See gld_getinfo and Bug 1165519
835 		 */
836 		ASSERT(glddev->gld_str_next == (gld_t *)&glddev->gld_str_next);
837 		ASSERT(glddev->gld_str_prev == (gld_t *)&glddev->gld_str_next);
838 
839 		gldremque(glddev);
840 		mutex_destroy(&glddev->gld_devlock);
841 		if (glddev->gld_broadcast != NULL)
842 			kmem_free(glddev->gld_broadcast, glddev->gld_addrlen);
843 		kmem_free(glddev, sizeof (glddev_t));
844 	}
845 	mutex_exit(&gld_device_list.gld_devlock);
846 
847 	return (DDI_FAILURE);
848 }
849 
850 /*
851  * gld_unregister (macinfo)
852  * remove the macinfo structure from local structures
853  * this is cleanup for a driver to be unloaded
854  */
855 int
856 gld_unregister(gld_mac_info_t *macinfo)
857 {
858 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
859 	glddev_t *glddev = mac_pvt->major_dev;
860 	gld_interface_t *ifp;
861 	int multisize = sizeof (gld_mcast_t) * glddev->gld_multisize;
862 
863 	mutex_enter(&glddev->gld_devlock);
864 	GLDM_LOCK(macinfo, RW_WRITER);
865 
866 	if (mac_pvt->nvlan > 0) {
867 		GLDM_UNLOCK(macinfo);
868 		mutex_exit(&glddev->gld_devlock);
869 		return (DDI_FAILURE);
870 	}
871 
872 #ifdef	GLD_DEBUG
873 	{
874 		int i;
875 
876 		for (i = 0; i < VLAN_HASHSZ; i++) {
877 			if ((mac_pvt->vlan_hash[i] != NULL))
878 				cmn_err(CE_PANIC,
879 				    "%s, line %d: "
880 				    "mac_pvt->vlan_hash[%d] != NULL",
881 				    __FILE__, __LINE__, i);
882 		}
883 	}
884 #endif
885 
886 	/* Delete this mac */
887 	gldremque(macinfo);
888 
889 	/* Disallow further entries to gld_recv() and gld_sched() */
890 	macinfo->gldm_GLD_flags |= GLD_UNREGISTERED;
891 
892 	GLDM_UNLOCK(macinfo);
893 	mutex_exit(&glddev->gld_devlock);
894 
895 	ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep;
896 	(*ifp->uninit)(macinfo);
897 
898 	ASSERT(mac_pvt->kstatp);
899 	kstat_delete(mac_pvt->kstatp);
900 
901 	ASSERT(GLDM_LOCK_INITED(macinfo));
902 	kmem_free(mac_pvt->curr_macaddr, macinfo->gldm_addrlen);
903 	kmem_free(mac_pvt->statistics, sizeof (struct gld_stats));
904 
905 	if (mac_pvt->mcast_table != NULL)
906 		kmem_free(mac_pvt->mcast_table, multisize);
907 	kmem_free(macinfo->gldm_mac_pvt, sizeof (gld_mac_pvt_t));
908 	macinfo->gldm_mac_pvt = (caddr_t)NULL;
909 
910 	/* We now have one fewer instance for this major device */
911 	mutex_enter(&gld_device_list.gld_devlock);
912 	glddev->gld_ndevice--;
913 	if (glddev->gld_ndevice == 0) {
914 		/* There should be no macinfos left */
915 		ASSERT(glddev->gld_mac_next ==
916 		    (gld_mac_info_t *)&glddev->gld_mac_next);
917 		ASSERT(glddev->gld_mac_prev ==
918 		    (gld_mac_info_t *)&glddev->gld_mac_next);
919 
920 		/*
921 		 * There should be no DL_UNATTACHED streams: the system
922 		 * should not have detached the "first" devinfo which has
923 		 * all the open style 2 streams.
924 		 *
925 		 * XXX This is not clear.  See gld_getinfo and Bug 1165519
926 		 */
927 		ASSERT(glddev->gld_str_next == (gld_t *)&glddev->gld_str_next);
928 		ASSERT(glddev->gld_str_prev == (gld_t *)&glddev->gld_str_next);
929 
930 		ddi_remove_minor_node(macinfo->gldm_devinfo, NULL);
931 		gldremque(glddev);
932 		mutex_destroy(&glddev->gld_devlock);
933 		if (glddev->gld_broadcast != NULL)
934 			kmem_free(glddev->gld_broadcast, glddev->gld_addrlen);
935 		kmem_free(glddev, sizeof (glddev_t));
936 	}
937 	mutex_exit(&gld_device_list.gld_devlock);
938 
939 	return (DDI_SUCCESS);
940 }
941 
942 /*
943  * gld_initstats
944  * called from gld_register
945  */
946 static int
947 gld_initstats(gld_mac_info_t *macinfo)
948 {
949 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
950 	struct gldkstats *sp;
951 	glddev_t *glddev;
952 	kstat_t *ksp;
953 	gld_interface_t *ifp;
954 
955 	glddev = mac_pvt->major_dev;
956 
957 	if ((ksp = kstat_create(glddev->gld_name, macinfo->gldm_ppa,
958 	    NULL, "net", KSTAT_TYPE_NAMED,
959 	    sizeof (struct gldkstats) / sizeof (kstat_named_t), 0)) == NULL) {
960 		cmn_err(CE_WARN,
961 		    "GLD: failed to create kstat structure for %s%d",
962 		    glddev->gld_name, macinfo->gldm_ppa);
963 		return (GLD_FAILURE);
964 	}
965 	mac_pvt->kstatp = ksp;
966 
967 	ksp->ks_update = gld_update_kstat;
968 	ksp->ks_private = (void *)macinfo;
969 
970 	sp = ksp->ks_data;
971 	kstat_named_init(&sp->glds_pktrcv, "ipackets", KSTAT_DATA_UINT32);
972 	kstat_named_init(&sp->glds_pktxmt, "opackets", KSTAT_DATA_UINT32);
973 	kstat_named_init(&sp->glds_errrcv, "ierrors", KSTAT_DATA_ULONG);
974 	kstat_named_init(&sp->glds_errxmt, "oerrors", KSTAT_DATA_ULONG);
975 	kstat_named_init(&sp->glds_bytexmt, "obytes", KSTAT_DATA_UINT32);
976 	kstat_named_init(&sp->glds_bytercv, "rbytes", KSTAT_DATA_UINT32);
977 	kstat_named_init(&sp->glds_multixmt, "multixmt", KSTAT_DATA_ULONG);
978 	kstat_named_init(&sp->glds_multircv, "multircv", KSTAT_DATA_ULONG);
979 	kstat_named_init(&sp->glds_brdcstxmt, "brdcstxmt", KSTAT_DATA_ULONG);
980 	kstat_named_init(&sp->glds_brdcstrcv, "brdcstrcv", KSTAT_DATA_ULONG);
981 	kstat_named_init(&sp->glds_blocked, "blocked", KSTAT_DATA_ULONG);
982 	kstat_named_init(&sp->glds_noxmtbuf, "noxmtbuf", KSTAT_DATA_ULONG);
983 	kstat_named_init(&sp->glds_norcvbuf, "norcvbuf", KSTAT_DATA_ULONG);
984 	kstat_named_init(&sp->glds_xmtretry, "xmtretry", KSTAT_DATA_ULONG);
985 	kstat_named_init(&sp->glds_intr, "intr", KSTAT_DATA_ULONG);
986 	kstat_named_init(&sp->glds_pktrcv64, "ipackets64", KSTAT_DATA_UINT64);
987 	kstat_named_init(&sp->glds_pktxmt64, "opackets64", KSTAT_DATA_UINT64);
988 	kstat_named_init(&sp->glds_bytexmt64, "obytes64", KSTAT_DATA_UINT64);
989 	kstat_named_init(&sp->glds_bytercv64, "rbytes64", KSTAT_DATA_UINT64);
990 	kstat_named_init(&sp->glds_unknowns, "unknowns", KSTAT_DATA_ULONG);
991 	kstat_named_init(&sp->glds_speed, "ifspeed", KSTAT_DATA_UINT64);
992 	kstat_named_init(&sp->glds_media, "media", KSTAT_DATA_CHAR);
993 	kstat_named_init(&sp->glds_prom, "promisc", KSTAT_DATA_CHAR);
994 
995 	kstat_named_init(&sp->glds_overflow, "oflo", KSTAT_DATA_ULONG);
996 	kstat_named_init(&sp->glds_underflow, "uflo", KSTAT_DATA_ULONG);
997 	kstat_named_init(&sp->glds_missed, "missed", KSTAT_DATA_ULONG);
998 
999 	kstat_named_init(&sp->glds_xmtbadinterp, "xmt_badinterp",
1000 	    KSTAT_DATA_UINT32);
1001 	kstat_named_init(&sp->glds_rcvbadinterp, "rcv_badinterp",
1002 	    KSTAT_DATA_UINT32);
1003 
1004 	ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep;
1005 
1006 	(*ifp->init)(macinfo);
1007 
1008 	kstat_install(ksp);
1009 
1010 	return (GLD_SUCCESS);
1011 }
1012 
1013 /* called from kstat mechanism, and from wsrv's get_statistics_req */
1014 static int
1015 gld_update_kstat(kstat_t *ksp, int rw)
1016 {
1017 	gld_mac_info_t	*macinfo;
1018 	gld_mac_pvt_t	*mac_pvt;
1019 	struct gldkstats *gsp;
1020 	struct gld_stats *stats;
1021 
1022 	if (rw == KSTAT_WRITE)
1023 		return (EACCES);
1024 
1025 	macinfo = (gld_mac_info_t *)ksp->ks_private;
1026 	ASSERT(macinfo != NULL);
1027 
1028 	GLDM_LOCK(macinfo, RW_WRITER);
1029 
1030 	if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) {
1031 		GLDM_UNLOCK(macinfo);
1032 		return (EIO);	/* this one's not ready yet */
1033 	}
1034 
1035 	if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) {
1036 		GLDM_UNLOCK(macinfo);
1037 		return (EIO);	/* this one's not ready any more */
1038 	}
1039 
1040 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
1041 	gsp = mac_pvt->kstatp->ks_data;
1042 	ASSERT(gsp);
1043 	stats = mac_pvt->statistics;
1044 
1045 	if (macinfo->gldm_get_stats)
1046 		(void) (*macinfo->gldm_get_stats)(macinfo, stats);
1047 
1048 	gsp->glds_pktxmt.value.ui32 = stats->glds_pktxmt64 & 0xffffffff;
1049 	gsp->glds_bytexmt.value.ui32 = stats->glds_bytexmt64 & 0xffffffff;
1050 	gsp->glds_multixmt.value.ul = stats->glds_multixmt;
1051 	gsp->glds_brdcstxmt.value.ul = stats->glds_brdcstxmt;
1052 	gsp->glds_noxmtbuf.value.ul = stats->glds_noxmtbuf;	/* 0 for now */
1053 	gsp->glds_xmtretry.value.ul = stats->glds_xmtretry;
1054 
1055 	gsp->glds_pktxmt64.value.ui64 = stats->glds_pktxmt64;
1056 	gsp->glds_bytexmt64.value.ui64 = stats->glds_bytexmt64;
1057 	gsp->glds_xmtbadinterp.value.ui32 = stats->glds_xmtbadinterp;
1058 
1059 	gsp->glds_pktrcv.value.ui32 = stats->glds_pktrcv64 & 0xffffffff;
1060 	gsp->glds_errxmt.value.ul = stats->glds_errxmt;
1061 	gsp->glds_errrcv.value.ul = stats->glds_errrcv;
1062 	gsp->glds_bytercv.value.ui32 = stats->glds_bytercv64 & 0xffffffff;
1063 	gsp->glds_multircv.value.ul = stats->glds_multircv;
1064 	gsp->glds_brdcstrcv.value.ul = stats->glds_brdcstrcv;
1065 	gsp->glds_blocked.value.ul = stats->glds_blocked;
1066 	gsp->glds_overflow.value.ul = stats->glds_overflow;
1067 	gsp->glds_underflow.value.ul = stats->glds_underflow;
1068 	gsp->glds_missed.value.ul = stats->glds_missed;
1069 	gsp->glds_norcvbuf.value.ul = stats->glds_norcvbuf +
1070 	    stats->glds_gldnorcvbuf;
1071 	gsp->glds_intr.value.ul = stats->glds_intr;
1072 
1073 	gsp->glds_speed.value.ui64 = stats->glds_speed;
1074 	gsp->glds_unknowns.value.ul = stats->glds_unknowns;
1075 	gsp->glds_pktrcv64.value.ui64 = stats->glds_pktrcv64;
1076 	gsp->glds_bytercv64.value.ui64 = stats->glds_bytercv64;
1077 	gsp->glds_rcvbadinterp.value.ui32 = stats->glds_rcvbadinterp;
1078 
1079 	if (mac_pvt->nprom)
1080 		(void) strcpy(gsp->glds_prom.value.c, "phys");
1081 	else if (mac_pvt->nprom_multi)
1082 		(void) strcpy(gsp->glds_prom.value.c, "multi");
1083 	else
1084 		(void) strcpy(gsp->glds_prom.value.c, "off");
1085 
1086 	(void) strcpy(gsp->glds_media.value.c, gld_media[
1087 	    stats->glds_media < sizeof (gld_media) / sizeof (gld_media[0])
1088 	    ? stats->glds_media : 0]);
1089 
1090 	switch (macinfo->gldm_type) {
1091 	case DL_ETHER:
1092 		gsp->glds_frame.value.ul = stats->glds_frame;
1093 		gsp->glds_crc.value.ul = stats->glds_crc;
1094 		gsp->glds_collisions.value.ul = stats->glds_collisions;
1095 		gsp->glds_excoll.value.ul = stats->glds_excoll;
1096 		gsp->glds_defer.value.ul = stats->glds_defer;
1097 		gsp->glds_short.value.ul = stats->glds_short;
1098 		gsp->glds_xmtlatecoll.value.ul = stats->glds_xmtlatecoll;
1099 		gsp->glds_nocarrier.value.ul = stats->glds_nocarrier;
1100 		gsp->glds_dot3_first_coll.value.ui32 =
1101 		    stats->glds_dot3_first_coll;
1102 		gsp->glds_dot3_multi_coll.value.ui32 =
1103 		    stats->glds_dot3_multi_coll;
1104 		gsp->glds_dot3_sqe_error.value.ui32 =
1105 		    stats->glds_dot3_sqe_error;
1106 		gsp->glds_dot3_mac_xmt_error.value.ui32 =
1107 		    stats->glds_dot3_mac_xmt_error;
1108 		gsp->glds_dot3_mac_rcv_error.value.ui32 =
1109 		    stats->glds_dot3_mac_rcv_error;
1110 		gsp->glds_dot3_frame_too_long.value.ui32 =
1111 		    stats->glds_dot3_frame_too_long;
1112 		(void) strcpy(gsp->glds_duplex.value.c, gld_duplex[
1113 		    stats->glds_duplex <
1114 		    sizeof (gld_duplex) / sizeof (gld_duplex[0]) ?
1115 		    stats->glds_duplex : 0]);
1116 		break;
1117 	case DL_TPR:
1118 		gsp->glds_dot5_line_error.value.ui32 =
1119 		    stats->glds_dot5_line_error;
1120 		gsp->glds_dot5_burst_error.value.ui32 =
1121 		    stats->glds_dot5_burst_error;
1122 		gsp->glds_dot5_signal_loss.value.ui32 =
1123 		    stats->glds_dot5_signal_loss;
1124 		gsp->glds_dot5_ace_error.value.ui32 =
1125 		    stats->glds_dot5_ace_error;
1126 		gsp->glds_dot5_internal_error.value.ui32 =
1127 		    stats->glds_dot5_internal_error;
1128 		gsp->glds_dot5_lost_frame_error.value.ui32 =
1129 		    stats->glds_dot5_lost_frame_error;
1130 		gsp->glds_dot5_frame_copied_error.value.ui32 =
1131 		    stats->glds_dot5_frame_copied_error;
1132 		gsp->glds_dot5_token_error.value.ui32 =
1133 		    stats->glds_dot5_token_error;
1134 		gsp->glds_dot5_freq_error.value.ui32 =
1135 		    stats->glds_dot5_freq_error;
1136 		break;
1137 	case DL_FDDI:
1138 		gsp->glds_fddi_mac_error.value.ui32 =
1139 		    stats->glds_fddi_mac_error;
1140 		gsp->glds_fddi_mac_lost.value.ui32 =
1141 		    stats->glds_fddi_mac_lost;
1142 		gsp->glds_fddi_mac_token.value.ui32 =
1143 		    stats->glds_fddi_mac_token;
1144 		gsp->glds_fddi_mac_tvx_expired.value.ui32 =
1145 		    stats->glds_fddi_mac_tvx_expired;
1146 		gsp->glds_fddi_mac_late.value.ui32 =
1147 		    stats->glds_fddi_mac_late;
1148 		gsp->glds_fddi_mac_ring_op.value.ui32 =
1149 		    stats->glds_fddi_mac_ring_op;
1150 		break;
1151 	case DL_IB:
1152 		break;
1153 	default:
1154 		break;
1155 	}
1156 
1157 	GLDM_UNLOCK(macinfo);
1158 
1159 #ifdef GLD_DEBUG
1160 	gld_check_assertions();
1161 	if (gld_debug & GLDRDE)
1162 		gld_sr_dump(macinfo);
1163 #endif
1164 
1165 	return (0);
1166 }
1167 
1168 static int
1169 gld_init_vlan_stats(gld_vlan_t *vlan)
1170 {
1171 	gld_mac_info_t *mac = vlan->gldv_mac;
1172 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt;
1173 	struct gldkstats *sp;
1174 	glddev_t *glddev;
1175 	kstat_t *ksp;
1176 	char *name;
1177 	int instance;
1178 
1179 	glddev = mac_pvt->major_dev;
1180 	name = glddev->gld_name;
1181 	instance = (vlan->gldv_id * GLD_VLAN_SCALE) + mac->gldm_ppa;
1182 
1183 	if ((ksp = kstat_create(name, instance,
1184 	    NULL, "net", KSTAT_TYPE_NAMED,
1185 	    sizeof (struct gldkstats) / sizeof (kstat_named_t), 0)) == NULL) {
1186 		cmn_err(CE_WARN,
1187 		    "GLD: failed to create kstat structure for %s%d",
1188 		    name, instance);
1189 		return (GLD_FAILURE);
1190 	}
1191 
1192 	vlan->gldv_kstatp = ksp;
1193 
1194 	ksp->ks_update = gld_update_vlan_kstat;
1195 	ksp->ks_private = (void *)vlan;
1196 
1197 	sp = ksp->ks_data;
1198 	kstat_named_init(&sp->glds_pktrcv, "ipackets", KSTAT_DATA_UINT32);
1199 	kstat_named_init(&sp->glds_pktxmt, "opackets", KSTAT_DATA_UINT32);
1200 	kstat_named_init(&sp->glds_errrcv, "ierrors", KSTAT_DATA_ULONG);
1201 	kstat_named_init(&sp->glds_errxmt, "oerrors", KSTAT_DATA_ULONG);
1202 	kstat_named_init(&sp->glds_bytexmt, "obytes", KSTAT_DATA_UINT32);
1203 	kstat_named_init(&sp->glds_bytercv, "rbytes", KSTAT_DATA_UINT32);
1204 	kstat_named_init(&sp->glds_multixmt, "multixmt", KSTAT_DATA_ULONG);
1205 	kstat_named_init(&sp->glds_multircv, "multircv", KSTAT_DATA_ULONG);
1206 	kstat_named_init(&sp->glds_brdcstxmt, "brdcstxmt", KSTAT_DATA_ULONG);
1207 	kstat_named_init(&sp->glds_brdcstrcv, "brdcstrcv", KSTAT_DATA_ULONG);
1208 	kstat_named_init(&sp->glds_blocked, "blocked", KSTAT_DATA_ULONG);
1209 	kstat_named_init(&sp->glds_noxmtbuf, "noxmtbuf", KSTAT_DATA_ULONG);
1210 	kstat_named_init(&sp->glds_norcvbuf, "norcvbuf", KSTAT_DATA_ULONG);
1211 	kstat_named_init(&sp->glds_xmtretry, "xmtretry", KSTAT_DATA_ULONG);
1212 	kstat_named_init(&sp->glds_intr, "intr", KSTAT_DATA_ULONG);
1213 	kstat_named_init(&sp->glds_pktrcv64, "ipackets64", KSTAT_DATA_UINT64);
1214 	kstat_named_init(&sp->glds_pktxmt64, "opackets64", KSTAT_DATA_UINT64);
1215 	kstat_named_init(&sp->glds_bytexmt64, "obytes64", KSTAT_DATA_UINT64);
1216 	kstat_named_init(&sp->glds_bytercv64, "rbytes64", KSTAT_DATA_UINT64);
1217 	kstat_named_init(&sp->glds_unknowns, "unknowns", KSTAT_DATA_ULONG);
1218 	kstat_named_init(&sp->glds_speed, "ifspeed", KSTAT_DATA_UINT64);
1219 	kstat_named_init(&sp->glds_media, "media", KSTAT_DATA_CHAR);
1220 	kstat_named_init(&sp->glds_prom, "promisc", KSTAT_DATA_CHAR);
1221 
1222 	kstat_named_init(&sp->glds_overflow, "oflo", KSTAT_DATA_ULONG);
1223 	kstat_named_init(&sp->glds_underflow, "uflo", KSTAT_DATA_ULONG);
1224 	kstat_named_init(&sp->glds_missed, "missed", KSTAT_DATA_ULONG);
1225 
1226 	kstat_named_init(&sp->glds_xmtbadinterp, "xmt_badinterp",
1227 	    KSTAT_DATA_UINT32);
1228 	kstat_named_init(&sp->glds_rcvbadinterp, "rcv_badinterp",
1229 	    KSTAT_DATA_UINT32);
1230 
1231 	kstat_install(ksp);
1232 	return (GLD_SUCCESS);
1233 }
1234 
1235 static int
1236 gld_update_vlan_kstat(kstat_t *ksp, int rw)
1237 {
1238 	gld_vlan_t	*vlan;
1239 	gld_mac_info_t	*macinfo;
1240 	struct gldkstats *gsp;
1241 	struct gld_stats *stats;
1242 	gld_mac_pvt_t *mac_pvt;
1243 	uint32_t media;
1244 
1245 	if (rw == KSTAT_WRITE)
1246 		return (EACCES);
1247 
1248 	vlan = (gld_vlan_t *)ksp->ks_private;
1249 	ASSERT(vlan != NULL);
1250 
1251 	macinfo = vlan->gldv_mac;
1252 	GLDM_LOCK(macinfo, RW_WRITER);
1253 
1254 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
1255 
1256 	gsp = vlan->gldv_kstatp->ks_data;
1257 	ASSERT(gsp);
1258 	stats = vlan->gldv_stats;
1259 
1260 	gsp->glds_pktxmt.value.ui32 = stats->glds_pktxmt64 & 0xffffffff;
1261 	gsp->glds_bytexmt.value.ui32 = stats->glds_bytexmt64 & 0xffffffff;
1262 	gsp->glds_errxmt.value.ul = stats->glds_errxmt;
1263 	gsp->glds_multixmt.value.ul = stats->glds_multixmt;
1264 	gsp->glds_brdcstxmt.value.ul = stats->glds_brdcstxmt;
1265 	gsp->glds_noxmtbuf.value.ul = stats->glds_noxmtbuf;
1266 	gsp->glds_xmtretry.value.ul = stats->glds_xmtretry;
1267 	gsp->glds_pktxmt64.value.ui64 = stats->glds_pktxmt64;
1268 	gsp->glds_bytexmt64.value.ui64 = stats->glds_bytexmt64;
1269 
1270 	gsp->glds_pktrcv.value.ui32 = stats->glds_pktrcv64 & 0xffffffff;
1271 	gsp->glds_bytercv.value.ui32 = stats->glds_bytercv64 & 0xffffffff;
1272 	gsp->glds_errrcv.value.ul = stats->glds_errrcv;
1273 	gsp->glds_multircv.value.ul = stats->glds_multircv;
1274 	gsp->glds_brdcstrcv.value.ul = stats->glds_brdcstrcv;
1275 	gsp->glds_blocked.value.ul = stats->glds_blocked;
1276 	gsp->glds_pktrcv64.value.ui64 = stats->glds_pktrcv64;
1277 	gsp->glds_bytercv64.value.ui64 = stats->glds_bytercv64;
1278 	gsp->glds_unknowns.value.ul = stats->glds_unknowns;
1279 	gsp->glds_xmtbadinterp.value.ui32 = stats->glds_xmtbadinterp;
1280 	gsp->glds_rcvbadinterp.value.ui32 = stats->glds_rcvbadinterp;
1281 
1282 	gsp->glds_speed.value.ui64 = mac_pvt->statistics->glds_speed;
1283 	media = mac_pvt->statistics->glds_media;
1284 	(void) strcpy(gsp->glds_media.value.c,
1285 	    gld_media[media < sizeof (gld_media) / sizeof (gld_media[0]) ?
1286 	    media : 0]);
1287 
1288 	GLDM_UNLOCK(macinfo);
1289 	return (0);
1290 }
1291 
1292 /*
1293  * The device dependent driver specifies gld_getinfo as its getinfo routine.
1294  */
1295 /*ARGSUSED*/
1296 int
1297 gld_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **resultp)
1298 {
1299 	dev_info_t	*devinfo;
1300 	minor_t		minor = getminor((dev_t)arg);
1301 	int		rc = DDI_FAILURE;
1302 
1303 	switch (cmd) {
1304 	case DDI_INFO_DEVT2DEVINFO:
1305 		if ((devinfo = gld_finddevinfo((dev_t)arg)) != NULL) {
1306 			*(dev_info_t **)resultp = devinfo;
1307 			rc = DDI_SUCCESS;
1308 		}
1309 		break;
1310 	case DDI_INFO_DEVT2INSTANCE:
1311 		/* Need static mapping for deferred attach */
1312 		if (minor == GLD_USE_STYLE2) {
1313 			/*
1314 			 * Style 2:  this minor number does not correspond to
1315 			 * any particular instance number.
1316 			 */
1317 			rc = DDI_FAILURE;
1318 		} else if (minor <= GLD_MAX_STYLE1_MINOR) {
1319 			/* Style 1:  calculate the PPA from the minor */
1320 			*resultp = (void *)(uintptr_t)
1321 			    GLD_STYLE1_MINOR_TO_PPA(minor);
1322 			rc = DDI_SUCCESS;
1323 		} else {
1324 			/* Clone:  look for it.  Not a static mapping */
1325 			if ((devinfo = gld_finddevinfo((dev_t)arg)) != NULL) {
1326 				*resultp = (void *)(uintptr_t)
1327 				    ddi_get_instance(devinfo);
1328 				rc = DDI_SUCCESS;
1329 			}
1330 		}
1331 		break;
1332 	}
1333 
1334 	return (rc);
1335 }
1336 
1337 /* called from gld_getinfo */
1338 dev_info_t *
1339 gld_finddevinfo(dev_t dev)
1340 {
1341 	minor_t		minor = getminor(dev);
1342 	glddev_t	*device;
1343 	gld_mac_info_t	*mac;
1344 	gld_vlan_t	*vlan;
1345 	gld_t		*str;
1346 	dev_info_t	*devinfo = NULL;
1347 	int		i;
1348 
1349 	if (minor == GLD_USE_STYLE2) {
1350 		/*
1351 		 * Style 2:  this minor number does not correspond to
1352 		 * any particular instance number.
1353 		 *
1354 		 * XXX We don't know what to say.  See Bug 1165519.
1355 		 */
1356 		return (NULL);
1357 	}
1358 
1359 	mutex_enter(&gld_device_list.gld_devlock);	/* hold the device */
1360 
1361 	device = gld_devlookup(getmajor(dev));
1362 	if (device == NULL) {
1363 		/* There are no attached instances of this device */
1364 		mutex_exit(&gld_device_list.gld_devlock);
1365 		return (NULL);
1366 	}
1367 
1368 	/*
1369 	 * Search all attached macs and streams.
1370 	 *
1371 	 * XXX We don't bother checking the DL_UNATTACHED streams since
1372 	 * we don't know what devinfo we should report back even if we
1373 	 * found the minor.  Maybe we should associate streams that are
1374 	 * not currently attached to a PPA with the "first" devinfo node
1375 	 * of the major device to attach -- the one that created the
1376 	 * minor node for the generic device.
1377 	 */
1378 	mutex_enter(&device->gld_devlock);
1379 
1380 	for (mac = device->gld_mac_next;
1381 	    mac != (gld_mac_info_t *)&device->gld_mac_next;
1382 	    mac = mac->gldm_next) {
1383 		gld_mac_pvt_t *pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt;
1384 
1385 		if (!(mac->gldm_GLD_flags & GLD_MAC_READY))
1386 			continue;	/* this one's not ready yet */
1387 		if (minor <= GLD_MAX_STYLE1_MINOR) {
1388 			/* Style 1 -- look for the corresponding PPA */
1389 			if (minor == GLD_STYLE1_PPA_TO_MINOR(mac->gldm_ppa)) {
1390 				devinfo = mac->gldm_devinfo;
1391 				goto out;	/* found it! */
1392 			} else
1393 				continue;	/* not this PPA */
1394 		}
1395 
1396 		/* We are looking for a clone */
1397 		for (i = 0; i < VLAN_HASHSZ; i++) {
1398 			for (vlan = pvt->vlan_hash[i];
1399 			    vlan != NULL; vlan = vlan->gldv_next) {
1400 				for (str = vlan->gldv_str_next;
1401 				    str != (gld_t *)&vlan->gldv_str_next;
1402 				    str = str->gld_next) {
1403 					ASSERT(str->gld_mac_info == mac);
1404 					if (minor == str->gld_minor) {
1405 						devinfo = mac->gldm_devinfo;
1406 						goto out;
1407 					}
1408 				}
1409 			}
1410 		}
1411 	}
1412 out:
1413 	mutex_exit(&device->gld_devlock);
1414 	mutex_exit(&gld_device_list.gld_devlock);
1415 	return (devinfo);
1416 }
1417 
1418 /*
1419  * STREAMS open routine.  The device dependent driver specifies this as its
1420  * open entry point.
1421  */
1422 /*ARGSUSED2*/
1423 int
1424 gld_open(queue_t *q, dev_t *dev, int flag, int sflag, cred_t *cred)
1425 {
1426 	gld_mac_pvt_t *mac_pvt;
1427 	gld_t *gld;
1428 	glddev_t *glddev;
1429 	gld_mac_info_t *macinfo;
1430 	minor_t minor = getminor(*dev);
1431 	gld_vlan_t *vlan;
1432 	t_uscalar_t ppa;
1433 
1434 	ASSERT(q != NULL);
1435 
1436 	if (minor > GLD_MAX_STYLE1_MINOR)
1437 		return (ENXIO);
1438 
1439 	ASSERT(q->q_ptr == NULL);	/* Clone device gives us a fresh Q */
1440 
1441 	/* Find our per-major glddev_t structure */
1442 	mutex_enter(&gld_device_list.gld_devlock);
1443 	glddev = gld_devlookup(getmajor(*dev));
1444 
1445 	/*
1446 	 * This glddev will hang around since detach (and therefore
1447 	 * gld_unregister) can't run while we're here in the open routine.
1448 	 */
1449 	mutex_exit(&gld_device_list.gld_devlock);
1450 
1451 	if (glddev == NULL)
1452 		return (ENXIO);
1453 
1454 #ifdef GLD_DEBUG
1455 	if (gld_debug & GLDPROT) {
1456 		if (minor == GLD_USE_STYLE2)
1457 			cmn_err(CE_NOTE, "gld_open(%p, Style 2)", (void *)q);
1458 		else
1459 			cmn_err(CE_NOTE, "gld_open(%p, Style 1, minor = %d)",
1460 			    (void *)q, minor);
1461 	}
1462 #endif
1463 
1464 	/*
1465 	 * get a per-stream structure and link things together so we
1466 	 * can easily find them later.
1467 	 */
1468 	gld = kmem_zalloc(sizeof (gld_t), KM_SLEEP);
1469 
1470 	/*
1471 	 * fill in the structure and state info
1472 	 */
1473 	gld->gld_qptr = q;
1474 	gld->gld_device = glddev;
1475 	gld->gld_state = DL_UNATTACHED;
1476 
1477 	/*
1478 	 * we must atomically find a free minor number and add the stream
1479 	 * to a list, because gld_findminor has to traverse the lists to
1480 	 * determine which minor numbers are free.
1481 	 */
1482 	mutex_enter(&glddev->gld_devlock);
1483 
1484 	/* find a free minor device number for the clone */
1485 	gld->gld_minor = gld_findminor(glddev);
1486 	if (gld->gld_minor == 0) {
1487 		mutex_exit(&glddev->gld_devlock);
1488 		kmem_free(gld, sizeof (gld_t));
1489 		return (ENOSR);
1490 	}
1491 
1492 #ifdef GLD_VERBOSE_DEBUG
1493 	if (gld_debug & GLDPROT)
1494 		cmn_err(CE_NOTE, "gld_open() gld ptr: %p minor: %d",
1495 		    (void *)gld, gld->gld_minor);
1496 #endif
1497 
1498 	if (minor == GLD_USE_STYLE2) {
1499 		gld->gld_style = DL_STYLE2;
1500 		*dev = makedevice(getmajor(*dev), gld->gld_minor);
1501 		WR(q)->q_ptr = q->q_ptr = (caddr_t)gld;
1502 		gldinsque(gld, glddev->gld_str_prev);
1503 #ifdef GLD_VERBOSE_DEBUG
1504 		if (gld_debug & GLDPROT)
1505 			cmn_err(CE_NOTE, "GLDstruct added to device list");
1506 #endif
1507 		(void) qassociate(q, -1);
1508 		goto done;
1509 	}
1510 
1511 	gld->gld_style = DL_STYLE1;
1512 
1513 	/* the PPA is actually 1 less than the minordev */
1514 	ppa = GLD_STYLE1_MINOR_TO_PPA(minor);
1515 
1516 	for (macinfo = glddev->gld_mac_next;
1517 	    macinfo != (gld_mac_info_t *)(&glddev->gld_mac_next);
1518 	    macinfo = macinfo->gldm_next) {
1519 		ASSERT(macinfo != NULL);
1520 		if (macinfo->gldm_ppa != ppa)
1521 			continue;
1522 
1523 		if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY))
1524 			continue;	/* this one's not ready yet */
1525 
1526 		/*
1527 		 * we found the correct PPA
1528 		 */
1529 		GLDM_LOCK(macinfo, RW_WRITER);
1530 
1531 		gld->gld_mac_info = macinfo;
1532 
1533 		if (macinfo->gldm_send_tagged != NULL)
1534 			gld->gld_send = macinfo->gldm_send_tagged;
1535 		else
1536 			gld->gld_send = macinfo->gldm_send;
1537 
1538 		/* now ready for action */
1539 		gld->gld_state = DL_UNBOUND;
1540 
1541 		if ((vlan = gld_get_vlan(macinfo, VLAN_VID_NONE)) == NULL) {
1542 			GLDM_UNLOCK(macinfo);
1543 			mutex_exit(&glddev->gld_devlock);
1544 			kmem_free(gld, sizeof (gld_t));
1545 			return (EIO);
1546 		}
1547 
1548 		mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
1549 		if (!mac_pvt->started) {
1550 			if (gld_start_mac(macinfo) != GLD_SUCCESS) {
1551 				gld_rem_vlan(vlan);
1552 				GLDM_UNLOCK(macinfo);
1553 				mutex_exit(&glddev->gld_devlock);
1554 				kmem_free(gld, sizeof (gld_t));
1555 				return (EIO);
1556 			}
1557 		}
1558 
1559 		gld->gld_vlan = vlan;
1560 		vlan->gldv_nstreams++;
1561 		gldinsque(gld, vlan->gldv_str_prev);
1562 		*dev = makedevice(getmajor(*dev), gld->gld_minor);
1563 		WR(q)->q_ptr = q->q_ptr = (caddr_t)gld;
1564 
1565 		GLDM_UNLOCK(macinfo);
1566 #ifdef GLD_VERBOSE_DEBUG
1567 		if (gld_debug & GLDPROT)
1568 			cmn_err(CE_NOTE,
1569 			    "GLDstruct added to instance list");
1570 #endif
1571 		break;
1572 	}
1573 
1574 	if (gld->gld_state == DL_UNATTACHED) {
1575 		mutex_exit(&glddev->gld_devlock);
1576 		kmem_free(gld, sizeof (gld_t));
1577 		return (ENXIO);
1578 	}
1579 
1580 done:
1581 	mutex_exit(&glddev->gld_devlock);
1582 	noenable(WR(q));	/* We'll do the qenables manually */
1583 	qprocson(q);		/* start the queues running */
1584 	qenable(WR(q));
1585 	return (0);
1586 }
1587 
1588 /*
1589  * normal stream close call checks current status and cleans up
1590  * data structures that were dynamically allocated
1591  */
1592 /*ARGSUSED1*/
1593 int
1594 gld_close(queue_t *q, int flag, cred_t *cred)
1595 {
1596 	gld_t	*gld = (gld_t *)q->q_ptr;
1597 	glddev_t *glddev = gld->gld_device;
1598 
1599 	ASSERT(q);
1600 	ASSERT(gld);
1601 
1602 #ifdef GLD_DEBUG
1603 	if (gld_debug & GLDPROT) {
1604 		cmn_err(CE_NOTE, "gld_close(%p, Style %d)",
1605 		    (void *)q, (gld->gld_style & 0x1) + 1);
1606 	}
1607 #endif
1608 
1609 	/* Hold all device streams lists still while we check for a macinfo */
1610 	mutex_enter(&glddev->gld_devlock);
1611 
1612 	if (gld->gld_mac_info != NULL) {
1613 		/* If there's a macinfo, block recv while we change state */
1614 		GLDM_LOCK(gld->gld_mac_info, RW_WRITER);
1615 		gld->gld_flags |= GLD_STR_CLOSING; /* no more rcv putnexts */
1616 		GLDM_UNLOCK(gld->gld_mac_info);
1617 	} else {
1618 		/* no mac DL_ATTACHED right now */
1619 		gld->gld_flags |= GLD_STR_CLOSING;
1620 	}
1621 
1622 	mutex_exit(&glddev->gld_devlock);
1623 
1624 	/*
1625 	 * qprocsoff before we call gld_unbind/gldunattach, so that
1626 	 * we know wsrv isn't in there trying to undo what we're doing.
1627 	 */
1628 	qprocsoff(q);
1629 
1630 	ASSERT(gld->gld_wput_count == 0);
1631 	gld->gld_wput_count = 0;	/* just in case */
1632 
1633 	if (gld->gld_state == DL_IDLE) {
1634 		/* Need to unbind */
1635 		ASSERT(gld->gld_mac_info != NULL);
1636 		(void) gld_unbind(WR(q), NULL);
1637 	}
1638 
1639 	if (gld->gld_state == DL_UNBOUND) {
1640 		/*
1641 		 * Need to unattach
1642 		 * For style 2 stream, gldunattach also
1643 		 * associate queue with NULL dip
1644 		 */
1645 		ASSERT(gld->gld_mac_info != NULL);
1646 		(void) gldunattach(WR(q), NULL);
1647 	}
1648 
1649 	/* disassociate the stream from the device */
1650 	q->q_ptr = WR(q)->q_ptr = NULL;
1651 
1652 	/*
1653 	 * Since we unattached above (if necessary), we know that we're
1654 	 * on the per-major list of unattached streams, rather than a
1655 	 * per-PPA list.  So we know we should hold the devlock.
1656 	 */
1657 	mutex_enter(&glddev->gld_devlock);
1658 	gldremque(gld);			/* remove from Style 2 list */
1659 	mutex_exit(&glddev->gld_devlock);
1660 
1661 	kmem_free(gld, sizeof (gld_t));
1662 
1663 	return (0);
1664 }
1665 
1666 /*
1667  * gld_rsrv (q)
1668  *	simple read service procedure
1669  *	purpose is to avoid the time it takes for packets
1670  *	to move through IP so we can get them off the board
1671  *	as fast as possible due to limited PC resources.
1672  *
1673  *	This is not normally used in the current implementation.  It
1674  *	can be selected with the undocumented property "fast_recv".
1675  *	If that property is set, gld_recv will send the packet
1676  *	upstream with a putq() rather than a putnext(), thus causing
1677  *	this routine to be scheduled.
1678  */
1679 int
1680 gld_rsrv(queue_t *q)
1681 {
1682 	mblk_t *mp;
1683 
1684 	while ((mp = getq(q)) != NULL) {
1685 		if (canputnext(q)) {
1686 			putnext(q, mp);
1687 		} else {
1688 			freemsg(mp);
1689 		}
1690 	}
1691 	return (0);
1692 }
1693 
1694 /*
1695  * gld_wput (q, mp)
1696  * general gld stream write put routine. Receives fastpath data from upper
1697  * modules and processes it immediately.  ioctl and M_PROTO/M_PCPROTO are
1698  * queued for later processing by the service procedure.
1699  */
1700 
1701 int
1702 gld_wput(queue_t *q, mblk_t *mp)
1703 {
1704 	gld_t  *gld = (gld_t *)(q->q_ptr);
1705 	int	rc;
1706 	boolean_t multidata = B_TRUE;
1707 	uint32_t upri;
1708 
1709 #ifdef GLD_DEBUG
1710 	if (gld_debug & GLDTRACE)
1711 		cmn_err(CE_NOTE, "gld_wput(%p %p): type %x",
1712 		    (void *)q, (void *)mp, DB_TYPE(mp));
1713 #endif
1714 	switch (DB_TYPE(mp)) {
1715 
1716 	case M_DATA:
1717 		/* fast data / raw support */
1718 		/* we must be DL_ATTACHED and DL_BOUND to do this */
1719 		/* Tricky to access memory without taking the mutex */
1720 		if ((gld->gld_flags & (GLD_RAW | GLD_FAST)) == 0 ||
1721 		    gld->gld_state != DL_IDLE) {
1722 			merror(q, mp, EPROTO);
1723 			break;
1724 		}
1725 		/*
1726 		 * Cleanup MBLK_VTAG in case it is set by other
1727 		 * modules. MBLK_VTAG is used to save the vtag information.
1728 		 */
1729 		GLD_CLEAR_MBLK_VTAG(mp);
1730 		multidata = B_FALSE;
1731 		/* LINTED: E_CASE_FALLTHRU */
1732 	case M_MULTIDATA:
1733 		/* Only call gld_start() directly if nothing queued ahead */
1734 		/* No guarantees about ordering with different threads */
1735 		if (q->q_first)
1736 			goto use_wsrv;
1737 
1738 		/*
1739 		 * This can happen if wsrv has taken off the last mblk but
1740 		 * is still processing it.
1741 		 */
1742 		membar_consumer();
1743 		if (gld->gld_in_wsrv)
1744 			goto use_wsrv;
1745 
1746 		/*
1747 		 * Keep a count of current wput calls to start.
1748 		 * Nonzero count delays any attempted DL_UNBIND.
1749 		 * See comments above gld_start().
1750 		 */
1751 		atomic_inc_32((uint32_t *)&gld->gld_wput_count);
1752 		membar_enter();
1753 
1754 		/* Recheck state now wput_count is set to prevent DL_UNBIND */
1755 		/* If this Q is in process of DL_UNBIND, don't call start */
1756 		if (gld->gld_state != DL_IDLE || gld->gld_in_unbind) {
1757 			/* Extremely unlikely */
1758 			atomic_dec_32((uint32_t *)&gld->gld_wput_count);
1759 			goto use_wsrv;
1760 		}
1761 
1762 		/*
1763 		 * Get the priority value. Note that in raw mode, the
1764 		 * per-packet priority value kept in b_band is ignored.
1765 		 */
1766 		upri = (gld->gld_flags & GLD_RAW) ? gld->gld_upri :
1767 		    UPRI(gld, mp->b_band);
1768 
1769 		rc = (multidata) ? gld_start_mdt(q, mp, GLD_WPUT) :
1770 		    gld_start(q, mp, GLD_WPUT, upri);
1771 
1772 		/* Allow DL_UNBIND again */
1773 		membar_exit();
1774 		atomic_dec_32((uint32_t *)&gld->gld_wput_count);
1775 
1776 		if (rc == GLD_NORESOURCES)
1777 			qenable(q);
1778 		break;	/*  Done with this packet */
1779 
1780 use_wsrv:
1781 		/* Q not empty, in DL_DETACH, or start gave NORESOURCES */
1782 		(void) putq(q, mp);
1783 		qenable(q);
1784 		break;
1785 
1786 	case M_IOCTL:
1787 		/* ioctl relies on wsrv single threading per queue */
1788 		(void) putq(q, mp);
1789 		qenable(q);
1790 		break;
1791 
1792 	case M_CTL:
1793 		(void) putq(q, mp);
1794 		qenable(q);
1795 		break;
1796 
1797 	case M_FLUSH:		/* canonical flush handling */
1798 		/* XXX Should these be FLUSHALL? */
1799 		if (*mp->b_rptr & FLUSHW)
1800 			flushq(q, 0);
1801 		if (*mp->b_rptr & FLUSHR) {
1802 			flushq(RD(q), 0);
1803 			*mp->b_rptr &= ~FLUSHW;
1804 			qreply(q, mp);
1805 		} else
1806 			freemsg(mp);
1807 		break;
1808 
1809 	case M_PROTO:
1810 	case M_PCPROTO:
1811 		/* these rely on wsrv single threading per queue */
1812 		(void) putq(q, mp);
1813 		qenable(q);
1814 		break;
1815 
1816 	default:
1817 #ifdef GLD_DEBUG
1818 		if (gld_debug & GLDETRACE)
1819 			cmn_err(CE_WARN,
1820 			    "gld: Unexpected packet type from queue: 0x%x",
1821 			    DB_TYPE(mp));
1822 #endif
1823 		freemsg(mp);
1824 	}
1825 	return (0);
1826 }
1827 
1828 /*
1829  * gld_wsrv - Incoming messages are processed according to the DLPI protocol
1830  * specification.
1831  *
1832  * wsrv is single-threaded per Q.  We make use of this to avoid taking the
1833  * lock for reading data items that are only ever written by us.
1834  */
1835 
1836 int
1837 gld_wsrv(queue_t *q)
1838 {
1839 	mblk_t *mp;
1840 	gld_t *gld = (gld_t *)q->q_ptr;
1841 	gld_mac_info_t *macinfo;
1842 	union DL_primitives *prim;
1843 	int err;
1844 	boolean_t multidata;
1845 	uint32_t upri;
1846 
1847 #ifdef GLD_DEBUG
1848 	if (gld_debug & GLDTRACE)
1849 		cmn_err(CE_NOTE, "gld_wsrv(%p)", (void *)q);
1850 #endif
1851 
1852 	ASSERT(!gld->gld_in_wsrv);
1853 
1854 	gld->gld_xwait = B_FALSE; /* We are now going to process this Q */
1855 
1856 	if (q->q_first == NULL)
1857 		return (0);
1858 
1859 	macinfo = gld->gld_mac_info;
1860 
1861 	/*
1862 	 * Help wput avoid a call to gld_start if there might be a message
1863 	 * previously queued by that thread being processed here.
1864 	 */
1865 	gld->gld_in_wsrv = B_TRUE;
1866 	membar_enter();
1867 
1868 	while ((mp = getq(q)) != NULL) {
1869 		switch (DB_TYPE(mp)) {
1870 		case M_DATA:
1871 		case M_MULTIDATA:
1872 			multidata = (DB_TYPE(mp) == M_MULTIDATA);
1873 
1874 			/*
1875 			 * retry of a previously processed UNITDATA_REQ
1876 			 * or is a RAW or FAST message from above.
1877 			 */
1878 			if (macinfo == NULL) {
1879 				/* No longer attached to a PPA, drop packet */
1880 				freemsg(mp);
1881 				break;
1882 			}
1883 
1884 			gld->gld_sched_ran = B_FALSE;
1885 			membar_enter();
1886 
1887 			/*
1888 			 * Get the priority value. Note that in raw mode, the
1889 			 * per-packet priority value kept in b_band is ignored.
1890 			 */
1891 			upri = (gld->gld_flags & GLD_RAW) ? gld->gld_upri :
1892 			    UPRI(gld, mp->b_band);
1893 
1894 			err = (multidata) ? gld_start_mdt(q, mp, GLD_WSRV) :
1895 			    gld_start(q, mp, GLD_WSRV, upri);
1896 			if (err == GLD_NORESOURCES) {
1897 				/* gld_sched will qenable us later */
1898 				gld->gld_xwait = B_TRUE; /* want qenable */
1899 				membar_enter();
1900 				/*
1901 				 * v2:  we're not holding the lock; it's
1902 				 * possible that the driver could have already
1903 				 * called gld_sched (following up on its
1904 				 * return of GLD_NORESOURCES), before we got a
1905 				 * chance to do the putbq() and set gld_xwait.
1906 				 * So if we saw a call to gld_sched that
1907 				 * examined this queue, since our call to
1908 				 * gld_start() above, then it's possible we've
1909 				 * already seen the only call to gld_sched()
1910 				 * we're ever going to see.  So we better retry
1911 				 * transmitting this packet right now.
1912 				 */
1913 				if (gld->gld_sched_ran) {
1914 #ifdef GLD_DEBUG
1915 					if (gld_debug & GLDTRACE)
1916 						cmn_err(CE_NOTE, "gld_wsrv: "
1917 						    "sched was called");
1918 #endif
1919 					break;	/* try again right now */
1920 				}
1921 				gld->gld_in_wsrv = B_FALSE;
1922 				return (0);
1923 			}
1924 			break;
1925 
1926 		case M_IOCTL:
1927 			(void) gld_ioctl(q, mp);
1928 			break;
1929 
1930 		case M_CTL:
1931 			if (macinfo == NULL) {
1932 				freemsg(mp);
1933 				break;
1934 			}
1935 
1936 			if (macinfo->gldm_mctl != NULL) {
1937 				GLDM_LOCK(macinfo, RW_WRITER);
1938 				(void) (*macinfo->gldm_mctl) (macinfo, q, mp);
1939 				GLDM_UNLOCK(macinfo);
1940 			} else {
1941 				/* This driver doesn't recognize, just drop */
1942 				freemsg(mp);
1943 			}
1944 			break;
1945 
1946 		case M_PROTO:	/* Will be an DLPI message of some type */
1947 		case M_PCPROTO:
1948 			if ((err = gld_cmds(q, mp)) != GLDE_OK) {
1949 				if (err == GLDE_RETRY) {
1950 					gld->gld_in_wsrv = B_FALSE;
1951 					return (0); /* quit while we're ahead */
1952 				}
1953 				prim = (union DL_primitives *)mp->b_rptr;
1954 				dlerrorack(q, mp, prim->dl_primitive, err, 0);
1955 			}
1956 			break;
1957 
1958 		default:
1959 			/* This should never happen */
1960 #ifdef GLD_DEBUG
1961 			if (gld_debug & GLDERRS)
1962 				cmn_err(CE_WARN,
1963 				    "gld_wsrv: db_type(%x) not supported",
1964 				    mp->b_datap->db_type);
1965 #endif
1966 			freemsg(mp);	/* unknown types are discarded */
1967 			break;
1968 		}
1969 	}
1970 
1971 	membar_exit();
1972 	gld->gld_in_wsrv = B_FALSE;
1973 	return (0);
1974 }
1975 
1976 /*
1977  * gld_start() can get called from gld_wput(), gld_wsrv(), or gld_unitdata().
1978  *
1979  * We only come directly from wput() in the GLD_FAST (fastpath) or RAW case.
1980  *
1981  * In particular, we must avoid calling gld_precv*() if we came from wput().
1982  * gld_precv*() is where we, on the transmit side, loop back our outgoing
1983  * packets to the receive side if we are in physical promiscuous mode.
1984  * Since the receive side holds a lock across its call to the upstream
1985  * putnext, and that upstream module could well have looped back to our
1986  * wput() routine on the same thread, we cannot call gld_precv* from here
1987  * for fear of causing a recursive lock entry in our receive code.
1988  *
1989  * There is a problem here when coming from gld_wput().  While wput
1990  * only comes here if the queue is attached to a PPA and bound to a SAP
1991  * and there are no messages on the queue ahead of the M_DATA that could
1992  * change that, it is theoretically possible that another thread could
1993  * now wput a DL_UNBIND and a DL_DETACH message, and the wsrv() routine
1994  * could wake up and process them, before we finish processing this
1995  * send of the M_DATA.  This can only possibly happen on a Style 2 RAW or
1996  * FAST (fastpath) stream:  non RAW/FAST streams always go through wsrv(),
1997  * and Style 1 streams only DL_DETACH in the close routine, where
1998  * qprocsoff() protects us.  If this happens we could end up calling
1999  * gldm_send() after we have detached the stream and possibly called
2000  * gldm_stop().  Worse, once the number of attached streams goes to zero,
2001  * detach/unregister could be called, and the macinfo could go away entirely.
2002  *
2003  * No one has ever seen this happen.
2004  *
2005  * It is some trouble to fix this, and we would rather not add any mutex
2006  * logic into the wput() routine, which is supposed to be a "fast"
2007  * path.
2008  *
2009  * What I've done is use an atomic counter to keep a count of the number
2010  * of threads currently calling gld_start() from wput() on this stream.
2011  * If DL_DETACH sees this as nonzero, it putbqs the request back onto
2012  * the queue and qenables, hoping to have better luck next time.  Since
2013  * people shouldn't be trying to send after they've asked to DL_DETACH,
2014  * hopefully very soon all the wput=>start threads should have returned
2015  * and the DL_DETACH will succeed.  It's hard to test this since the odds
2016  * of the failure even trying to happen are so small.  I probably could
2017  * have ignored the whole issue and never been the worse for it.
2018  *
2019  * Because some GLDv2 Ethernet drivers do not allow the size of transmitted
2020  * packet to be greater than ETHERMAX, we must first strip the VLAN tag
2021  * from a tagged packet before passing it to the driver's gld_send() entry
2022  * point function, and pass the VLAN tag as a separate argument. The
2023  * gld_send() function may fail. In that case, the packet will need to be
2024  * queued in order to be processed again in GLD's service routine. As the
2025  * VTAG has already been stripped at that time, we save the VTAG information
2026  * in (the unused fields of) dblk using GLD_SAVE_MBLK_VTAG(), so that the
2027  * VTAG can also be queued and be able to be got when gld_start() is called
2028  * next time from gld_wsrv().
2029  *
2030  * Some rules to use GLD_{CLEAR|SAVE}_MBLK_VTAG macros:
2031  *
2032  * - GLD_SAVE_MBLK_VTAG() must be called to save the VTAG information each time
2033  *   the message is queued by putbq().
2034  *
2035  * - GLD_CLEAR_MBLK_VTAG() must be called to clear the bogus VTAG information
2036  *   (if any) in dblk before the message is passed to the gld_start() function.
2037  */
2038 static int
2039 gld_start(queue_t *q, mblk_t *mp, int caller, uint32_t upri)
2040 {
2041 	mblk_t *nmp;
2042 	gld_t *gld = (gld_t *)q->q_ptr;
2043 	gld_mac_info_t *macinfo;
2044 	gld_mac_pvt_t *mac_pvt;
2045 	int rc;
2046 	gld_interface_t *ifp;
2047 	pktinfo_t pktinfo;
2048 	uint32_t vtag, vid;
2049 	uint32_t raw_vtag = 0;
2050 	gld_vlan_t *vlan;
2051 	struct gld_stats *stats0, *stats = NULL;
2052 
2053 	ASSERT(DB_TYPE(mp) == M_DATA);
2054 	macinfo = gld->gld_mac_info;
2055 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2056 	ifp = mac_pvt->interfacep;
2057 	vlan = (gld_vlan_t *)gld->gld_vlan;
2058 	vid = vlan->gldv_id;
2059 
2060 	/*
2061 	 * If this interface is a VLAN, the kstats of corresponding
2062 	 * "VLAN 0" should also be updated. Note that the gld_vlan_t
2063 	 * structure for VLAN 0 might not exist if there are no DLPI
2064 	 * consumers attaching on VLAN 0. Fortunately we can directly
2065 	 * access VLAN 0's kstats from macinfo.
2066 	 *
2067 	 * Therefore, stats0 (VLAN 0's kstats) must always be
2068 	 * updated, and stats must to be updated if it is not NULL.
2069 	 */
2070 	stats0 = mac_pvt->statistics;
2071 	if (vid != VLAN_VID_NONE)
2072 		stats = vlan->gldv_stats;
2073 
2074 	if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_TX) != 0) {
2075 #ifdef GLD_DEBUG
2076 		if (gld_debug & GLDERRS)
2077 			cmn_err(CE_WARN,
2078 			    "gld_start: failed to interpret outbound packet");
2079 #endif
2080 		goto badarg;
2081 	}
2082 
2083 	vtag = VLAN_VID_NONE;
2084 	raw_vtag = GLD_GET_MBLK_VTAG(mp);
2085 	if (GLD_VTAG_TCI(raw_vtag) != 0) {
2086 		uint16_t raw_pri, raw_vid, evid;
2087 
2088 		/*
2089 		 * Tagged packet.
2090 		 */
2091 		raw_pri = GLD_VTAG_PRI(raw_vtag);
2092 		raw_vid = GLD_VTAG_VID(raw_vtag);
2093 		GLD_CLEAR_MBLK_VTAG(mp);
2094 
2095 		if (gld->gld_flags & GLD_RAW) {
2096 			/*
2097 			 * In raw mode, we only expect untagged packets or
2098 			 * special priority-tagged packets on a VLAN stream.
2099 			 * Drop the packet if its VID is not zero.
2100 			 */
2101 			if (vid != VLAN_VID_NONE && raw_vid != VLAN_VID_NONE)
2102 				goto badarg;
2103 
2104 			/*
2105 			 * If it is raw mode, use the per-stream priority if
2106 			 * the priority is not specified in the packet.
2107 			 * Otherwise, ignore the priority bits in the packet.
2108 			 */
2109 			upri = (raw_pri != 0) ? raw_pri : upri;
2110 		}
2111 
2112 		if (vid == VLAN_VID_NONE && vid != raw_vid) {
2113 			gld_vlan_t *tmp_vlan;
2114 
2115 			/*
2116 			 * This link is a physical link but the packet is
2117 			 * a VLAN tagged packet, the kstats of corresponding
2118 			 * VLAN (if any) should also be updated.
2119 			 */
2120 			tmp_vlan = gld_find_vlan(macinfo, raw_vid);
2121 			if (tmp_vlan != NULL)
2122 				stats = tmp_vlan->gldv_stats;
2123 		}
2124 
2125 		evid = (vid == VLAN_VID_NONE) ? raw_vid : vid;
2126 		if (evid != VLAN_VID_NONE || upri != 0)
2127 			vtag = GLD_MAKE_VTAG(upri, VLAN_CFI_ETHER, evid);
2128 	} else {
2129 		/*
2130 		 * Untagged packet:
2131 		 * Get vtag from the attached PPA of this stream.
2132 		 */
2133 		if ((vid != VLAN_VID_NONE) ||
2134 		    ((macinfo->gldm_type == DL_ETHER) && (upri != 0))) {
2135 			vtag = GLD_MAKE_VTAG(upri, VLAN_CFI_ETHER, vid);
2136 		}
2137 	}
2138 
2139 	/*
2140 	 * We're not holding the lock for this check.  If the promiscuous
2141 	 * state is in flux it doesn't matter much if we get this wrong.
2142 	 */
2143 	if (mac_pvt->nprom > 0) {
2144 		/*
2145 		 * We want to loopback to the receive side, but to avoid
2146 		 * recursive lock entry:  if we came from wput(), which
2147 		 * could have looped back via IP from our own receive
2148 		 * interrupt thread, we decline this request.  wput()
2149 		 * will then queue the packet for wsrv().  This means
2150 		 * that when snoop is running we don't get the advantage
2151 		 * of the wput() multithreaded direct entry to the
2152 		 * driver's send routine.
2153 		 */
2154 		if (caller == GLD_WPUT) {
2155 			GLD_SAVE_MBLK_VTAG(mp, raw_vtag);
2156 			(void) putbq(q, mp);
2157 			return (GLD_NORESOURCES);
2158 		}
2159 		if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY)
2160 			nmp = dupmsg_noloan(mp);
2161 		else
2162 			nmp = dupmsg(mp);
2163 	} else
2164 		nmp = NULL;		/* we need no loopback */
2165 
2166 	if (ifp->hdr_size > 0 &&
2167 	    pktinfo.pktLen > ifp->hdr_size + (vtag == 0 ? 0 : VTAG_SIZE) +
2168 	    macinfo->gldm_maxpkt) {
2169 		if (nmp)
2170 			freemsg(nmp);	/* free the duped message */
2171 #ifdef GLD_DEBUG
2172 		if (gld_debug & GLDERRS)
2173 			cmn_err(CE_WARN,
2174 			    "gld_start: oversize outbound packet, size %d,"
2175 			    "max %d", pktinfo.pktLen,
2176 			    ifp->hdr_size + (vtag == 0 ? 0 : VTAG_SIZE) +
2177 			    macinfo->gldm_maxpkt);
2178 #endif
2179 		goto badarg;
2180 	}
2181 
2182 	rc = (*gld->gld_send)(macinfo, mp, vtag);
2183 
2184 	if (rc != GLD_SUCCESS) {
2185 		if (rc == GLD_NORESOURCES) {
2186 			ATOMIC_BUMP(stats0, stats, glds_xmtretry, 1);
2187 			GLD_SAVE_MBLK_VTAG(mp, raw_vtag);
2188 			(void) putbq(q, mp);
2189 		} else {
2190 			/* transmit error; drop the packet */
2191 			freemsg(mp);
2192 			/* We're supposed to count failed attempts as well */
2193 			UPDATE_STATS(stats0, stats, pktinfo, 1);
2194 #ifdef GLD_DEBUG
2195 			if (gld_debug & GLDERRS)
2196 				cmn_err(CE_WARN,
2197 				    "gld_start: gldm_send failed %d", rc);
2198 #endif
2199 		}
2200 		if (nmp)
2201 			freemsg(nmp);	/* free the dupped message */
2202 		return (rc);
2203 	}
2204 
2205 	UPDATE_STATS(stats0, stats, pktinfo, 1);
2206 
2207 	/*
2208 	 * Loopback case. The message needs to be returned back on
2209 	 * the read side. This would silently fail if the dupmsg fails
2210 	 * above. This is probably OK, if there is no memory to dup the
2211 	 * block, then there isn't much we could do anyway.
2212 	 */
2213 	if (nmp) {
2214 		GLDM_LOCK(macinfo, RW_WRITER);
2215 		gld_precv(macinfo, nmp, vtag, stats);
2216 		GLDM_UNLOCK(macinfo);
2217 	}
2218 
2219 	return (GLD_SUCCESS);
2220 badarg:
2221 	freemsg(mp);
2222 
2223 	ATOMIC_BUMP(stats0, stats, glds_xmtbadinterp, 1);
2224 	return (GLD_BADARG);
2225 }
2226 
2227 /*
2228  * With MDT V.2 a single message mp can have one header area and multiple
2229  * payload areas. A packet is described by dl_pkt_info, and each packet can
2230  * span multiple payload areas (currently with TCP, each packet will have one
2231  * header and at the most two payload areas). MACs might have a limit on the
2232  * number of payload segments (i.e. per packet scatter-gather limit), and
2233  * MDT V.2 has a way of specifying that with mdt_span_limit; the MAC driver
2234  * might also have a limit on the total number of payloads in a message, and
2235  * that is specified by mdt_max_pld.
2236  */
2237 static int
2238 gld_start_mdt(queue_t *q, mblk_t *mp, int caller)
2239 {
2240 	mblk_t *nextmp;
2241 	gld_t *gld = (gld_t *)q->q_ptr;
2242 	gld_mac_info_t *macinfo = gld->gld_mac_info;
2243 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2244 	int numpacks, mdtpacks;
2245 	gld_interface_t *ifp = mac_pvt->interfacep;
2246 	pktinfo_t pktinfo;
2247 	gld_vlan_t *vlan = (gld_vlan_t *)gld->gld_vlan;
2248 	boolean_t doloop = B_FALSE;
2249 	multidata_t *dlmdp;
2250 	pdescinfo_t pinfo;
2251 	pdesc_t *dl_pkt;
2252 	void *cookie;
2253 	uint_t totLen = 0;
2254 
2255 	ASSERT(DB_TYPE(mp) == M_MULTIDATA);
2256 
2257 	/*
2258 	 * We're not holding the lock for this check.  If the promiscuous
2259 	 * state is in flux it doesn't matter much if we get this wrong.
2260 	 */
2261 	if (mac_pvt->nprom > 0) {
2262 		/*
2263 		 * We want to loopback to the receive side, but to avoid
2264 		 * recursive lock entry:  if we came from wput(), which
2265 		 * could have looped back via IP from our own receive
2266 		 * interrupt thread, we decline this request.  wput()
2267 		 * will then queue the packet for wsrv().  This means
2268 		 * that when snoop is running we don't get the advantage
2269 		 * of the wput() multithreaded direct entry to the
2270 		 * driver's send routine.
2271 		 */
2272 		if (caller == GLD_WPUT) {
2273 			(void) putbq(q, mp);
2274 			return (GLD_NORESOURCES);
2275 		}
2276 		doloop = B_TRUE;
2277 
2278 		/*
2279 		 * unlike the M_DATA case, we don't have to call
2280 		 * dupmsg_noloan here because mmd_transform
2281 		 * (called by gld_precv_mdt) will make a copy of
2282 		 * each dblk.
2283 		 */
2284 	}
2285 
2286 	while (mp != NULL) {
2287 		/*
2288 		 * The lower layer driver only gets a single multidata
2289 		 * message; this also makes it easier to handle noresources.
2290 		 */
2291 		nextmp = mp->b_cont;
2292 		mp->b_cont = NULL;
2293 
2294 		/*
2295 		 * Get number of packets in this message; if nothing
2296 		 * to transmit, go to next message.
2297 		 */
2298 		dlmdp = mmd_getmultidata(mp);
2299 		if ((mdtpacks = (int)mmd_getcnt(dlmdp, NULL, NULL)) == 0) {
2300 			freemsg(mp);
2301 			mp = nextmp;
2302 			continue;
2303 		}
2304 
2305 		/*
2306 		 * Run interpreter to populate media specific pktinfo fields.
2307 		 * This collects per MDT message information like sap,
2308 		 * broad/multicast etc.
2309 		 */
2310 		(void) (*ifp->interpreter_mdt)(macinfo, mp, NULL, &pktinfo,
2311 		    GLD_MDT_TX);
2312 
2313 		numpacks = (*macinfo->gldm_mdt_pre)(macinfo, mp, &cookie);
2314 
2315 		if (numpacks > 0) {
2316 			/*
2317 			 * Driver indicates it can transmit at least 1, and
2318 			 * possibly all, packets in MDT message.
2319 			 */
2320 			int count = numpacks;
2321 
2322 			for (dl_pkt = mmd_getfirstpdesc(dlmdp, &pinfo);
2323 			    (dl_pkt != NULL);
2324 			    dl_pkt = mmd_getnextpdesc(dl_pkt, &pinfo)) {
2325 				/*
2326 				 * Format this packet by adding link header and
2327 				 * adjusting pdescinfo to include it; get
2328 				 * packet length.
2329 				 */
2330 				(void) (*ifp->interpreter_mdt)(macinfo, NULL,
2331 				    &pinfo, &pktinfo, GLD_MDT_TXPKT);
2332 
2333 				totLen += pktinfo.pktLen;
2334 
2335 				/*
2336 				 * Loop back packet before handing to the
2337 				 * driver.
2338 				 */
2339 				if (doloop &&
2340 				    mmd_adjpdesc(dl_pkt, &pinfo) != NULL) {
2341 					GLDM_LOCK(macinfo, RW_WRITER);
2342 					gld_precv_mdt(macinfo, vlan, mp,
2343 					    dl_pkt, &pktinfo);
2344 					GLDM_UNLOCK(macinfo);
2345 				}
2346 
2347 				/*
2348 				 * And send off to driver.
2349 				 */
2350 				(*macinfo->gldm_mdt_send)(macinfo, cookie,
2351 				    &pinfo);
2352 
2353 				/*
2354 				 * Be careful not to invoke getnextpdesc if we
2355 				 * already sent the last packet, since driver
2356 				 * might have posted it to hardware causing a
2357 				 * completion and freemsg() so the MDT data
2358 				 * structures might not be valid anymore.
2359 				 */
2360 				if (--count == 0)
2361 					break;
2362 			}
2363 			(*macinfo->gldm_mdt_post)(macinfo, mp, cookie);
2364 			pktinfo.pktLen = totLen;
2365 			UPDATE_STATS(vlan->gldv_stats, NULL, pktinfo, numpacks);
2366 
2367 			/*
2368 			 * In the noresources case (when driver indicates it
2369 			 * can not transmit all packets in the MDT message),
2370 			 * adjust to skip the first few packets on retrial.
2371 			 */
2372 			if (numpacks != mdtpacks) {
2373 				/*
2374 				 * Release already processed packet descriptors.
2375 				 */
2376 				for (count = 0; count < numpacks; count++) {
2377 					dl_pkt = mmd_getfirstpdesc(dlmdp,
2378 					    &pinfo);
2379 					mmd_rempdesc(dl_pkt);
2380 				}
2381 				ATOMIC_BUMP(vlan->gldv_stats, NULL,
2382 				    glds_xmtretry, 1);
2383 				mp->b_cont = nextmp;
2384 				(void) putbq(q, mp);
2385 				return (GLD_NORESOURCES);
2386 			}
2387 		} else if (numpacks == 0) {
2388 			/*
2389 			 * Driver indicates it can not transmit any packets
2390 			 * currently and will request retrial later.
2391 			 */
2392 			ATOMIC_BUMP(vlan->gldv_stats, NULL, glds_xmtretry, 1);
2393 			mp->b_cont = nextmp;
2394 			(void) putbq(q, mp);
2395 			return (GLD_NORESOURCES);
2396 		} else {
2397 			ASSERT(numpacks == -1);
2398 			/*
2399 			 * We're supposed to count failed attempts as well.
2400 			 */
2401 			dl_pkt = mmd_getfirstpdesc(dlmdp, &pinfo);
2402 			while (dl_pkt != NULL) {
2403 				/*
2404 				 * Call interpreter to determine total packet
2405 				 * bytes that are being dropped.
2406 				 */
2407 				(void) (*ifp->interpreter_mdt)(macinfo, NULL,
2408 				    &pinfo, &pktinfo, GLD_MDT_TXPKT);
2409 
2410 				totLen += pktinfo.pktLen;
2411 
2412 				dl_pkt = mmd_getnextpdesc(dl_pkt, &pinfo);
2413 			}
2414 			pktinfo.pktLen = totLen;
2415 			UPDATE_STATS(vlan->gldv_stats, NULL, pktinfo, mdtpacks);
2416 
2417 			/*
2418 			 * Transmit error; drop the message, move on
2419 			 * to the next one.
2420 			 */
2421 			freemsg(mp);
2422 		}
2423 
2424 		/*
2425 		 * Process the next multidata block, if there is one.
2426 		 */
2427 		mp = nextmp;
2428 	}
2429 
2430 	return (GLD_SUCCESS);
2431 }
2432 
2433 /*
2434  * gld_intr (macinfo)
2435  */
2436 uint_t
2437 gld_intr(gld_mac_info_t *macinfo)
2438 {
2439 	ASSERT(macinfo != NULL);
2440 
2441 	if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY))
2442 		return (DDI_INTR_UNCLAIMED);
2443 
2444 	return ((*macinfo->gldm_intr)(macinfo));
2445 }
2446 
2447 /*
2448  * gld_sched (macinfo)
2449  *
2450  * This routine scans the streams that refer to a specific macinfo
2451  * structure and causes the STREAMS scheduler to try to run them if
2452  * they are marked as waiting for the transmit buffer.
2453  */
2454 void
2455 gld_sched(gld_mac_info_t *macinfo)
2456 {
2457 	gld_mac_pvt_t *mac_pvt;
2458 	gld_t *gld;
2459 	gld_vlan_t *vlan;
2460 	int i;
2461 
2462 	ASSERT(macinfo != NULL);
2463 
2464 	GLDM_LOCK(macinfo, RW_WRITER);
2465 
2466 	if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) {
2467 		/* We're probably being called from a leftover interrupt */
2468 		GLDM_UNLOCK(macinfo);
2469 		return;
2470 	}
2471 
2472 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2473 
2474 	for (i = 0; i < VLAN_HASHSZ; i++) {
2475 		for (vlan = mac_pvt->vlan_hash[i];
2476 		    vlan != NULL; vlan = vlan->gldv_next) {
2477 			for (gld = vlan->gldv_str_next;
2478 			    gld != (gld_t *)&vlan->gldv_str_next;
2479 			    gld = gld->gld_next) {
2480 				ASSERT(gld->gld_mac_info == macinfo);
2481 				gld->gld_sched_ran = B_TRUE;
2482 				membar_enter();
2483 				if (gld->gld_xwait) {
2484 					gld->gld_xwait = B_FALSE;
2485 					qenable(WR(gld->gld_qptr));
2486 				}
2487 			}
2488 		}
2489 	}
2490 
2491 	GLDM_UNLOCK(macinfo);
2492 }
2493 
2494 /*
2495  * gld_precv (macinfo, mp, vtag, stats)
2496  * called from gld_start to loopback a packet when in promiscuous mode
2497  *
2498  * VLAN 0's statistics need to be updated. If stats is not NULL,
2499  * it needs to be updated as well.
2500  */
2501 static void
2502 gld_precv(gld_mac_info_t *macinfo, mblk_t *mp, uint32_t vtag,
2503     struct gld_stats *stats)
2504 {
2505 	gld_mac_pvt_t *mac_pvt;
2506 	gld_interface_t *ifp;
2507 	pktinfo_t pktinfo;
2508 
2509 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
2510 
2511 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2512 	ifp = mac_pvt->interfacep;
2513 
2514 	/*
2515 	 * call the media specific packet interpreter routine
2516 	 */
2517 	if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RXLOOP) != 0) {
2518 		freemsg(mp);
2519 		BUMP(mac_pvt->statistics, stats, glds_rcvbadinterp, 1);
2520 #ifdef GLD_DEBUG
2521 		if (gld_debug & GLDERRS)
2522 			cmn_err(CE_WARN,
2523 			    "gld_precv: interpreter failed");
2524 #endif
2525 		return;
2526 	}
2527 
2528 	/*
2529 	 * Update the vtag information.
2530 	 */
2531 	pktinfo.isTagged = (vtag != VLAN_VID_NONE);
2532 	pktinfo.vid = GLD_VTAG_VID(vtag);
2533 	pktinfo.cfi = GLD_VTAG_CFI(vtag);
2534 	pktinfo.user_pri = GLD_VTAG_PRI(vtag);
2535 
2536 	gld_sendup(macinfo, &pktinfo, mp, gld_paccept);
2537 }
2538 
2539 /*
2540  * Called from gld_start_mdt to loopback packet(s) when in promiscuous mode.
2541  * Note that 'vlan' is always a physical link, because MDT can only be
2542  * enabled on non-VLAN streams.
2543  */
2544 /*ARGSUSED*/
2545 static void
2546 gld_precv_mdt(gld_mac_info_t *macinfo, gld_vlan_t *vlan, mblk_t *mp,
2547     pdesc_t *dl_pkt, pktinfo_t *pktinfo)
2548 {
2549 	mblk_t *adjmp;
2550 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2551 	gld_interface_t *ifp = mac_pvt->interfacep;
2552 
2553 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
2554 
2555 	/*
2556 	 * Get source/destination.
2557 	 */
2558 	(void) (*ifp->interpreter_mdt)(macinfo, mp, NULL, pktinfo,
2559 	    GLD_MDT_RXLOOP);
2560 	if ((adjmp = mmd_transform(dl_pkt)) != NULL)
2561 		gld_sendup(macinfo, pktinfo, adjmp, gld_paccept);
2562 }
2563 
2564 /*
2565  * gld_recv (macinfo, mp)
2566  * called with an mac-level packet in a mblock; take the maclock,
2567  * try the ip4q and ip6q hack, and otherwise call gld_sendup.
2568  *
2569  * V0 drivers already are holding the mutex when they call us.
2570  */
2571 void
2572 gld_recv(gld_mac_info_t *macinfo, mblk_t *mp)
2573 {
2574 	gld_recv_tagged(macinfo, mp, VLAN_VTAG_NONE);
2575 }
2576 
2577 void
2578 gld_recv_tagged(gld_mac_info_t *macinfo, mblk_t *mp, uint32_t vtag)
2579 {
2580 	gld_mac_pvt_t *mac_pvt;
2581 	char pbuf[3*GLD_MAX_ADDRLEN];
2582 	pktinfo_t pktinfo;
2583 	gld_interface_t *ifp;
2584 	queue_t *ipq = NULL;
2585 	gld_vlan_t *vlan = NULL, *vlan0 = NULL, *vlann = NULL;
2586 	struct gld_stats *stats0, *stats = NULL;
2587 	uint32_t vid;
2588 	int err;
2589 
2590 	ASSERT(macinfo != NULL);
2591 	ASSERT(mp->b_datap->db_ref);
2592 
2593 	GLDM_LOCK(macinfo, RW_READER);
2594 
2595 	if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) {
2596 		/* We're probably being called from a leftover interrupt */
2597 		freemsg(mp);
2598 		goto done;
2599 	}
2600 
2601 	/*
2602 	 * If this packet is a VLAN tagged packet, the kstats of corresponding
2603 	 * "VLAN 0" should also be updated. We can directly access VLAN 0's
2604 	 * kstats from macinfo.
2605 	 *
2606 	 * Further, the packets needs to be passed to VLAN 0 if there is
2607 	 * any DLPI consumer on VLAN 0 who is interested in tagged packets
2608 	 * (DL_PROMISC_SAP is on or is bounded to ETHERTYPE_VLAN SAP).
2609 	 */
2610 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
2611 	stats0 = mac_pvt->statistics;
2612 
2613 	vid = GLD_VTAG_VID(vtag);
2614 	vlan0 = gld_find_vlan(macinfo, VLAN_VID_NONE);
2615 	if (vid != VLAN_VID_NONE) {
2616 		/*
2617 		 * If there are no physical DLPI consumers interested in the
2618 		 * VLAN packet, clear vlan0.
2619 		 */
2620 		if ((vlan0 != NULL) && (vlan0->gldv_nvlan_sap == 0))
2621 			vlan0 = NULL;
2622 		/*
2623 		 * vlann is the VLAN with the same VID as the VLAN packet.
2624 		 */
2625 		vlann = gld_find_vlan(macinfo, vid);
2626 		if (vlann != NULL)
2627 			stats = vlann->gldv_stats;
2628 	}
2629 
2630 	vlan = (vid == VLAN_VID_NONE) ? vlan0 : vlann;
2631 
2632 	ifp = mac_pvt->interfacep;
2633 	err = (*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RXQUICK);
2634 
2635 	BUMP(stats0, stats, glds_bytercv64, pktinfo.pktLen);
2636 	BUMP(stats0, stats, glds_pktrcv64, 1);
2637 
2638 	if ((vlann == NULL) && (vlan0 == NULL)) {
2639 		freemsg(mp);
2640 		goto done;
2641 	}
2642 
2643 	/*
2644 	 * Check whether underlying media code supports the IPQ hack:
2645 	 *
2646 	 * - the interpreter could quickly parse the packet
2647 	 * - the device type supports IPQ (ethernet and IPoIB)
2648 	 * - there is one, and only one, IP stream bound (to this VLAN)
2649 	 * - that stream is a "fastpath" stream
2650 	 * - the packet is of type ETHERTYPE_IP or ETHERTYPE_IPV6
2651 	 * - there are no streams in promiscuous mode (on this VLAN)
2652 	 * - if this packet is tagged, there is no need to send this
2653 	 *   packet to physical streams
2654 	 */
2655 	if ((err != 0) && ((vlan != NULL) && (vlan->gldv_nprom == 0)) &&
2656 	    (vlan == vlan0 || vlan0 == NULL)) {
2657 		switch (pktinfo.ethertype) {
2658 		case ETHERTYPE_IP:
2659 			ipq = vlan->gldv_ipq;
2660 			break;
2661 		case ETHERTYPE_IPV6:
2662 			ipq = vlan->gldv_ipv6q;
2663 			break;
2664 		}
2665 	}
2666 
2667 	/*
2668 	 * Special case for IP; we can simply do the putnext here, if:
2669 	 * o The IPQ hack is possible (ipq != NULL).
2670 	 * o the packet is specifically for me, and therefore:
2671 	 * - the packet is not multicast or broadcast (fastpath only
2672 	 *   wants unicast packets).
2673 	 *
2674 	 * o the stream is not asserting flow control.
2675 	 */
2676 	if (ipq != NULL &&
2677 	    pktinfo.isForMe &&
2678 	    canputnext(ipq)) {
2679 		/*
2680 		 * Skip the mac header. We know there is no LLC1/SNAP header
2681 		 * in this packet
2682 		 */
2683 		mp->b_rptr += pktinfo.macLen;
2684 		putnext(ipq, mp);
2685 		goto done;
2686 	}
2687 
2688 	/*
2689 	 * call the media specific packet interpreter routine
2690 	 */
2691 	if ((*ifp->interpreter)(macinfo, mp, &pktinfo, GLD_RX) != 0) {
2692 		BUMP(stats0, stats, glds_rcvbadinterp, 1);
2693 #ifdef GLD_DEBUG
2694 		if (gld_debug & GLDERRS)
2695 			cmn_err(CE_WARN,
2696 			    "gld_recv_tagged: interpreter failed");
2697 #endif
2698 		freemsg(mp);
2699 		goto done;
2700 	}
2701 
2702 	/*
2703 	 * This is safe even if vtag is VLAN_VTAG_NONE
2704 	 */
2705 	pktinfo.vid = vid;
2706 	pktinfo.cfi = GLD_VTAG_CFI(vtag);
2707 #ifdef GLD_DEBUG
2708 	if (pktinfo.cfi != VLAN_CFI_ETHER)
2709 		cmn_err(CE_WARN, "gld_recv_tagged: non-ETHER CFI");
2710 #endif
2711 	pktinfo.user_pri = GLD_VTAG_PRI(vtag);
2712 	pktinfo.isTagged = (vtag != VLAN_VID_NONE);
2713 
2714 #ifdef GLD_DEBUG
2715 	if ((gld_debug & GLDRECV) &&
2716 	    (!(gld_debug & GLDNOBR) ||
2717 	    (!pktinfo.isBroadcast && !pktinfo.isMulticast))) {
2718 		char pbuf2[3*GLD_MAX_ADDRLEN];
2719 
2720 		cmn_err(CE_CONT, "gld_recv_tagged: machdr=<%s -> %s>\n",
2721 		    gld_macaddr_sprintf(pbuf, pktinfo.shost,
2722 		    macinfo->gldm_addrlen), gld_macaddr_sprintf(pbuf2,
2723 		    pktinfo.dhost, macinfo->gldm_addrlen));
2724 		cmn_err(CE_CONT, "gld_recv_tagged: VlanId %d UserPri %d\n",
2725 		    pktinfo.vid,
2726 		    pktinfo.user_pri);
2727 		cmn_err(CE_CONT, "gld_recv_tagged: ethertype: %4x Len: %4d "
2728 		    "Hdr: %d,%d isMulticast: %s\n",
2729 		    pktinfo.ethertype,
2730 		    pktinfo.pktLen,
2731 		    pktinfo.macLen,
2732 		    pktinfo.hdrLen,
2733 		    pktinfo.isMulticast ? "Y" : "N");
2734 	}
2735 #endif
2736 
2737 	gld_sendup(macinfo, &pktinfo, mp, gld_accept);
2738 
2739 done:
2740 	GLDM_UNLOCK(macinfo);
2741 }
2742 
2743 /* =================================================================== */
2744 /* receive group: called from gld_recv and gld_precv* with maclock held */
2745 /* =================================================================== */
2746 
2747 /*
2748  * Search all the streams attached to the specified VLAN looking for
2749  * those eligible to receive the packet.
2750  * Note that in order to avoid an extra dupmsg(), if this is the first
2751  * eligible stream, remember it (in fgldp) so that we can send up the
2752  * message after this function.
2753  *
2754  * Return errno if fails. Currently the only error is ENOMEM.
2755  */
2756 static int
2757 gld_sendup_vlan(gld_vlan_t *vlan, pktinfo_t *pktinfo, mblk_t *mp,
2758     int (*acceptfunc)(), void (*send)(), int (*cansend)(), gld_t **fgldp)
2759 {
2760 	mblk_t *nmp;
2761 	gld_t *gld;
2762 	int err = 0;
2763 
2764 	ASSERT(vlan != NULL);
2765 	for (gld = vlan->gldv_str_next; gld != (gld_t *)&vlan->gldv_str_next;
2766 	    gld = gld->gld_next) {
2767 #ifdef GLD_VERBOSE_DEBUG
2768 		cmn_err(CE_NOTE, "gld_sendup_vlan: SAP: %4x QPTR: %p "
2769 		    "QSTATE: %s", gld->gld_sap, (void *)gld->gld_qptr,
2770 		    gld->gld_state == DL_IDLE ? "IDLE" : "NOT IDLE");
2771 #endif
2772 		ASSERT(gld->gld_qptr != NULL);
2773 		ASSERT(gld->gld_state == DL_IDLE ||
2774 		    gld->gld_state == DL_UNBOUND);
2775 		ASSERT(gld->gld_vlan == vlan);
2776 
2777 		if (gld->gld_state != DL_IDLE)
2778 			continue;	/* not eligible to receive */
2779 		if (gld->gld_flags & GLD_STR_CLOSING)
2780 			continue;	/* not eligible to receive */
2781 
2782 #ifdef GLD_DEBUG
2783 		if ((gld_debug & GLDRECV) &&
2784 		    (!(gld_debug & GLDNOBR) ||
2785 		    (!pktinfo->isBroadcast && !pktinfo->isMulticast)))
2786 			cmn_err(CE_NOTE,
2787 			    "gld_sendup: queue sap: %4x promis: %s %s %s",
2788 			    gld->gld_sap,
2789 			    gld->gld_flags & GLD_PROM_PHYS ? "phys " : "     ",
2790 			    gld->gld_flags & GLD_PROM_SAP  ? "sap  " : "     ",
2791 			    gld->gld_flags & GLD_PROM_MULT ? "multi" : "     ");
2792 #endif
2793 
2794 		/*
2795 		 * The accept function differs depending on whether this is
2796 		 * a packet that we received from the wire or a loopback.
2797 		 */
2798 		if ((*acceptfunc)(gld, pktinfo)) {
2799 			/* sap matches */
2800 			pktinfo->wasAccepted = 1; /* known protocol */
2801 
2802 			if (!(*cansend)(gld->gld_qptr)) {
2803 				/*
2804 				 * Upper stream is not accepting messages, i.e.
2805 				 * it is flow controlled, therefore we will
2806 				 * forgo sending the message up this stream.
2807 				 */
2808 #ifdef GLD_DEBUG
2809 				if (gld_debug & GLDETRACE)
2810 					cmn_err(CE_WARN,
2811 					    "gld_sendup: canput failed");
2812 #endif
2813 				BUMP(vlan->gldv_stats, NULL, glds_blocked, 1);
2814 				qenable(gld->gld_qptr);
2815 				continue;
2816 			}
2817 
2818 			/*
2819 			 * In order to avoid an extra dupmsg(), remember this
2820 			 * gld if this is the first eligible stream.
2821 			 */
2822 			if (*fgldp == NULL) {
2823 				*fgldp = gld;
2824 				continue;
2825 			}
2826 
2827 			/* duplicate the packet for this stream */
2828 			nmp = dupmsg(mp);
2829 			if (nmp == NULL) {
2830 				BUMP(vlan->gldv_stats, NULL,
2831 				    glds_gldnorcvbuf, 1);
2832 #ifdef GLD_DEBUG
2833 				if (gld_debug & GLDERRS)
2834 					cmn_err(CE_WARN,
2835 					    "gld_sendup: dupmsg failed");
2836 #endif
2837 				/* couldn't get resources; drop it */
2838 				err = ENOMEM;
2839 				break;
2840 			}
2841 			/* pass the message up the stream */
2842 			gld_passon(gld, nmp, pktinfo, send);
2843 		}
2844 	}
2845 	return (err);
2846 }
2847 
2848 /*
2849  * gld_sendup (macinfo, pktinfo, mp, acceptfunc)
2850  * called with an ethernet packet in an mblk; must decide whether
2851  * packet is for us and which streams to queue it to.
2852  */
2853 static void
2854 gld_sendup(gld_mac_info_t *macinfo, pktinfo_t *pktinfo,
2855     mblk_t *mp, int (*acceptfunc)())
2856 {
2857 	gld_t *fgld = NULL;
2858 	void (*send)(queue_t *qp, mblk_t *mp);
2859 	int (*cansend)(queue_t *qp);
2860 	gld_vlan_t *vlan0, *vlann = NULL;
2861 	struct gld_stats *stats0, *stats = NULL;
2862 	int err = 0;
2863 
2864 #ifdef GLD_DEBUG
2865 	if (gld_debug & GLDTRACE)
2866 		cmn_err(CE_NOTE, "gld_sendup(%p, %p)", (void *)mp,
2867 		    (void *)macinfo);
2868 #endif
2869 
2870 	ASSERT(mp != NULL);
2871 	ASSERT(macinfo != NULL);
2872 	ASSERT(pktinfo != NULL);
2873 	ASSERT(GLDM_LOCK_HELD(macinfo));
2874 
2875 	/*
2876 	 * The tagged packets should also be looped back (transmit-side)
2877 	 * or sent up (receive-side) to VLAN 0 if VLAN 0 is set to
2878 	 * DL_PROMISC_SAP or there is any DLPI consumer bind to the
2879 	 * ETHERTYPE_VLAN SAP. The kstats of VLAN 0 needs to be updated
2880 	 * as well.
2881 	 */
2882 	stats0 = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->statistics;
2883 	vlan0 = gld_find_vlan(macinfo, VLAN_VID_NONE);
2884 	if (pktinfo->vid != VLAN_VID_NONE) {
2885 		if ((vlan0 != NULL) && (vlan0->gldv_nvlan_sap == 0))
2886 			vlan0 = NULL;
2887 		vlann = gld_find_vlan(macinfo, pktinfo->vid);
2888 		if (vlann != NULL)
2889 			stats = vlann->gldv_stats;
2890 	}
2891 
2892 	ASSERT((vlan0 != NULL) || (vlann != NULL));
2893 
2894 	/*
2895 	 * The "fast" in "GLDOPT_FAST_RECV" refers to the speed at which
2896 	 * gld_recv returns to the caller's interrupt routine.  The total
2897 	 * network throughput would normally be lower when selecting this
2898 	 * option, because we putq the messages and process them later,
2899 	 * instead of sending them with putnext now.  Some time critical
2900 	 * device might need this, so it's here but undocumented.
2901 	 */
2902 	if (macinfo->gldm_options & GLDOPT_FAST_RECV) {
2903 		send = (void (*)(queue_t *, mblk_t *))putq;
2904 		cansend = canput;
2905 	} else {
2906 		send = (void (*)(queue_t *, mblk_t *))putnext;
2907 		cansend = canputnext;
2908 	}
2909 
2910 	/*
2911 	 * Send the packets for all eligible streams.
2912 	 */
2913 	if (vlan0 != NULL) {
2914 		err = gld_sendup_vlan(vlan0, pktinfo, mp, acceptfunc, send,
2915 		    cansend, &fgld);
2916 	}
2917 	if ((err == 0) && (vlann != NULL)) {
2918 		err = gld_sendup_vlan(vlann, pktinfo, mp, acceptfunc, send,
2919 		    cansend, &fgld);
2920 	}
2921 
2922 	ASSERT(mp);
2923 	/* send the original dup of the packet up the first stream found */
2924 	if (fgld)
2925 		gld_passon(fgld, mp, pktinfo, send);
2926 	else
2927 		freemsg(mp);	/* no streams matched */
2928 
2929 	/* We do not count looped back packets */
2930 	if (acceptfunc == gld_paccept)
2931 		return;		/* transmit loopback case */
2932 
2933 	if (pktinfo->isBroadcast)
2934 		BUMP(stats0, stats, glds_brdcstrcv, 1);
2935 	else if (pktinfo->isMulticast)
2936 		BUMP(stats0, stats, glds_multircv, 1);
2937 
2938 	/* No stream accepted this packet */
2939 	if (!pktinfo->wasAccepted)
2940 		BUMP(stats0, stats, glds_unknowns, 1);
2941 }
2942 
2943 #define	GLD_IS_PHYS(gld)	\
2944 	(((gld_vlan_t *)gld->gld_vlan)->gldv_id == VLAN_VID_NONE)
2945 
2946 /*
2947  * A packet matches a stream if:
2948  *      The stream's VLAN id is the same as the one in the packet.
2949  *  and the stream accepts EtherType encoded packets and the type matches
2950  *  or  the stream accepts LLC packets and the packet is an LLC packet
2951  */
2952 #define	MATCH(stream, pktinfo) \
2953 	((((gld_vlan_t *)stream->gld_vlan)->gldv_id == pktinfo->vid) && \
2954 	((stream->gld_ethertype && stream->gld_sap == pktinfo->ethertype) || \
2955 	(!stream->gld_ethertype && pktinfo->isLLC)))
2956 
2957 /*
2958  * This function validates a packet for sending up a particular
2959  * stream. The message header has been parsed and its characteristic
2960  * are recorded in the pktinfo data structure. The streams stack info
2961  * are presented in gld data structures.
2962  */
2963 static int
2964 gld_accept(gld_t *gld, pktinfo_t *pktinfo)
2965 {
2966 	/*
2967 	 * if there is no match do not bother checking further.
2968 	 * Note that it is okay to examine gld_vlan because
2969 	 * macinfo->gldm_lock is held.
2970 	 *
2971 	 * Because all tagged packets have SAP value ETHERTYPE_VLAN,
2972 	 * these packets will pass the SAP filter check if the stream
2973 	 * is a ETHERTYPE_VLAN listener.
2974 	 */
2975 	if ((!MATCH(gld, pktinfo) && !(gld->gld_flags & GLD_PROM_SAP) &&
2976 	    !(GLD_IS_PHYS(gld) && gld->gld_sap == ETHERTYPE_VLAN &&
2977 	    pktinfo->isTagged)))
2978 		return (0);
2979 
2980 	/*
2981 	 * We don't accept any packet from the hardware if we originated it.
2982 	 * (Contrast gld_paccept, the send-loopback accept function.)
2983 	 */
2984 	if (pktinfo->isLooped)
2985 		return (0);
2986 
2987 	/*
2988 	 * If the packet is broadcast or sent to us directly we will accept it.
2989 	 * Also we will accept multicast packets requested by the stream.
2990 	 */
2991 	if (pktinfo->isForMe || pktinfo->isBroadcast ||
2992 	    gld_mcmatch(gld, pktinfo))
2993 		return (1);
2994 
2995 	/*
2996 	 * Finally, accept anything else if we're in promiscuous mode
2997 	 */
2998 	if (gld->gld_flags & GLD_PROM_PHYS)
2999 		return (1);
3000 
3001 	return (0);
3002 }
3003 
3004 /*
3005  * Return TRUE if the given multicast address is one
3006  * of those that this particular Stream is interested in.
3007  */
3008 static int
3009 gld_mcmatch(gld_t *gld, pktinfo_t *pktinfo)
3010 {
3011 	/*
3012 	 * Return FALSE if not a multicast address.
3013 	 */
3014 	if (!pktinfo->isMulticast)
3015 		return (0);
3016 
3017 	/*
3018 	 * Check if all multicasts have been enabled for this Stream
3019 	 */
3020 	if (gld->gld_flags & GLD_PROM_MULT)
3021 		return (1);
3022 
3023 	/*
3024 	 * Return FALSE if no multicast addresses enabled for this Stream.
3025 	 */
3026 	if (!gld->gld_mcast)
3027 		return (0);
3028 
3029 	/*
3030 	 * Otherwise, look for it in the table.
3031 	 */
3032 	return (gld_multicast(pktinfo->dhost, gld));
3033 }
3034 
3035 /*
3036  * gld_multicast determines if the address is a multicast address for
3037  * this stream.
3038  */
3039 static int
3040 gld_multicast(unsigned char *macaddr, gld_t *gld)
3041 {
3042 	int i;
3043 
3044 	ASSERT(GLDM_LOCK_HELD(gld->gld_mac_info));
3045 
3046 	if (!gld->gld_mcast)
3047 		return (0);
3048 
3049 	for (i = 0; i < gld->gld_multicnt; i++) {
3050 		if (gld->gld_mcast[i]) {
3051 			ASSERT(gld->gld_mcast[i]->gldm_refcnt);
3052 			if (mac_eq(gld->gld_mcast[i]->gldm_addr, macaddr,
3053 			    gld->gld_mac_info->gldm_addrlen))
3054 				return (1);
3055 		}
3056 	}
3057 
3058 	return (0);
3059 }
3060 
3061 /*
3062  * accept function for looped back packets
3063  */
3064 static int
3065 gld_paccept(gld_t *gld, pktinfo_t *pktinfo)
3066 {
3067 	/*
3068 	 * Note that it is okay to examine gld_vlan because macinfo->gldm_lock
3069 	 * is held.
3070 	 *
3071 	 * If a stream is a ETHERTYPE_VLAN listener, it must
3072 	 * accept all tagged packets as those packets have SAP value
3073 	 * ETHERTYPE_VLAN.
3074 	 */
3075 	return (gld->gld_flags & GLD_PROM_PHYS &&
3076 	    (MATCH(gld, pktinfo) || gld->gld_flags & GLD_PROM_SAP ||
3077 	    (GLD_IS_PHYS(gld) && gld->gld_sap == ETHERTYPE_VLAN &&
3078 	    pktinfo->isTagged)));
3079 
3080 }
3081 
3082 static void
3083 gld_passon(gld_t *gld, mblk_t *mp, pktinfo_t *pktinfo,
3084 	void (*send)(queue_t *qp, mblk_t *mp))
3085 {
3086 	boolean_t is_phys = GLD_IS_PHYS(gld);
3087 	int skiplen;
3088 	boolean_t addtag = B_FALSE;
3089 	uint32_t vtag = 0;
3090 
3091 #ifdef GLD_DEBUG
3092 	if (gld_debug & GLDTRACE)
3093 		cmn_err(CE_NOTE, "gld_passon(%p, %p, %p)", (void *)gld,
3094 		    (void *)mp, (void *)pktinfo);
3095 
3096 	if ((gld_debug & GLDRECV) && (!(gld_debug & GLDNOBR) ||
3097 	    (!pktinfo->isBroadcast && !pktinfo->isMulticast)))
3098 		cmn_err(CE_NOTE, "gld_passon: q: %p mblk: %p minor: %d sap: %x",
3099 		    (void *)gld->gld_qptr->q_next, (void *)mp, gld->gld_minor,
3100 		    gld->gld_sap);
3101 #endif
3102 	/*
3103 	 * Figure out how much of the packet header to throw away.
3104 	 *
3105 	 * Normal DLPI (non RAW/FAST) streams also want the
3106 	 * DL_UNITDATA_IND M_PROTO message block prepended to the M_DATA.
3107 	 */
3108 	if (gld->gld_flags & GLD_RAW) {
3109 		/*
3110 		 * The packet will be tagged in the following cases:
3111 		 *   - if priority is not 0
3112 		 *   - a tagged packet sent on a physical link
3113 		 */
3114 		if ((pktinfo->isTagged && is_phys) || (pktinfo->user_pri != 0))
3115 			addtag = B_TRUE;
3116 		skiplen = 0;
3117 	} else {
3118 		/*
3119 		 * The packet will be tagged if it meets all below conditions:
3120 		 *   -  this is a physical stream
3121 		 *   -  this packet is tagged packet
3122 		 *   -  the stream is either a DL_PROMISC_SAP listener or a
3123 		 *	ETHERTYPE_VLAN listener
3124 		 */
3125 		if (is_phys && pktinfo->isTagged &&
3126 		    ((gld->gld_sap == ETHERTYPE_VLAN) ||
3127 		    (gld->gld_flags & GLD_PROM_SAP))) {
3128 			addtag = B_TRUE;
3129 		}
3130 
3131 		skiplen = pktinfo->macLen;		/* skip mac header */
3132 		if (gld->gld_ethertype)
3133 			skiplen += pktinfo->hdrLen;	/* skip any extra */
3134 	}
3135 	if (skiplen >= pktinfo->pktLen) {
3136 		/*
3137 		 * If the interpreter did its job right, then it cannot be
3138 		 * asking us to skip more bytes than are in the packet!
3139 		 * However, there could be zero data bytes left after the
3140 		 * amount to skip.  DLPI specifies that passed M_DATA blocks
3141 		 * should contain at least one byte of data, so if we have
3142 		 * none we just drop it.
3143 		 */
3144 		ASSERT(!(skiplen > pktinfo->pktLen));
3145 		freemsg(mp);
3146 		return;
3147 	}
3148 
3149 	if (addtag) {
3150 		mblk_t *savemp = mp;
3151 
3152 		vtag = GLD_MAKE_VTAG(pktinfo->user_pri, pktinfo->cfi,
3153 		    is_phys ? pktinfo->vid : VLAN_VID_NONE);
3154 		if ((mp = gld_insert_vtag_ether(mp, vtag)) == NULL) {
3155 			freemsg(savemp);
3156 			return;
3157 		}
3158 	}
3159 
3160 	/*
3161 	 * Skip over the header(s), taking care to possibly handle message
3162 	 * fragments shorter than the amount we need to skip.  Hopefully
3163 	 * the driver will put the entire packet, or at least the entire
3164 	 * header, into a single message block.  But we handle it if not.
3165 	 */
3166 	while (skiplen >= MBLKL(mp)) {
3167 		mblk_t *savemp = mp;
3168 		skiplen -= MBLKL(mp);
3169 		mp = mp->b_cont;
3170 		ASSERT(mp != NULL);	/* because skiplen < pktinfo->pktLen */
3171 		freeb(savemp);
3172 	}
3173 	mp->b_rptr += skiplen;
3174 
3175 	/* Add M_PROTO if necessary, and pass upstream */
3176 	if (((gld->gld_flags & GLD_FAST) && !pktinfo->isMulticast &&
3177 	    !pktinfo->isBroadcast) || (gld->gld_flags & GLD_RAW)) {
3178 		/* RAW/FAST: just send up the M_DATA */
3179 		(*send)(gld->gld_qptr, mp);
3180 	} else {
3181 		/* everybody else wants to see a unitdata_ind structure */
3182 		mp = gld_addudind(gld, mp, pktinfo, addtag);
3183 		if (mp)
3184 			(*send)(gld->gld_qptr, mp);
3185 		/* if it failed, gld_addudind already bumped statistic */
3186 	}
3187 }
3188 
3189 /*
3190  * gld_addudind(gld, mp, pktinfo)
3191  * format a DL_UNITDATA_IND message to be sent upstream to the user
3192  */
3193 static mblk_t *
3194 gld_addudind(gld_t *gld, mblk_t *mp, pktinfo_t *pktinfo, boolean_t tagged)
3195 {
3196 	gld_mac_info_t		*macinfo = gld->gld_mac_info;
3197 	gld_vlan_t		*vlan = (gld_vlan_t *)gld->gld_vlan;
3198 	dl_unitdata_ind_t	*dludindp;
3199 	mblk_t			*nmp;
3200 	int			size;
3201 	int			type;
3202 
3203 #ifdef GLD_DEBUG
3204 	if (gld_debug & GLDTRACE)
3205 		cmn_err(CE_NOTE, "gld_addudind(%p, %p, %p)", (void *)gld,
3206 		    (void *)mp, (void *)pktinfo);
3207 #endif
3208 	ASSERT(macinfo != NULL);
3209 
3210 	/*
3211 	 * Allocate the DL_UNITDATA_IND M_PROTO header, if allocation fails
3212 	 * might as well discard since we can't go further
3213 	 */
3214 	size = sizeof (dl_unitdata_ind_t) +
3215 	    2 * (macinfo->gldm_addrlen + abs(macinfo->gldm_saplen));
3216 	if ((nmp = allocb(size, BPRI_MED)) == NULL) {
3217 		freemsg(mp);
3218 		BUMP(vlan->gldv_stats, NULL, glds_gldnorcvbuf, 1);
3219 #ifdef GLD_DEBUG
3220 		if (gld_debug & GLDERRS)
3221 			cmn_err(CE_WARN,
3222 			    "gld_addudind: allocb failed");
3223 #endif
3224 		return ((mblk_t *)NULL);
3225 	}
3226 	DB_TYPE(nmp) = M_PROTO;
3227 	nmp->b_rptr = nmp->b_datap->db_lim - size;
3228 
3229 	if (tagged)
3230 		type = ETHERTYPE_VLAN;
3231 	else
3232 		type = (gld->gld_ethertype) ? pktinfo->ethertype : 0;
3233 
3234 
3235 	/*
3236 	 * now setup the DL_UNITDATA_IND header
3237 	 *
3238 	 * XXX This looks broken if the saps aren't two bytes.
3239 	 */
3240 	dludindp = (dl_unitdata_ind_t *)nmp->b_rptr;
3241 	dludindp->dl_primitive = DL_UNITDATA_IND;
3242 	dludindp->dl_src_addr_length =
3243 	    dludindp->dl_dest_addr_length = macinfo->gldm_addrlen +
3244 	    abs(macinfo->gldm_saplen);
3245 	dludindp->dl_dest_addr_offset = sizeof (dl_unitdata_ind_t);
3246 	dludindp->dl_src_addr_offset = dludindp->dl_dest_addr_offset +
3247 	    dludindp->dl_dest_addr_length;
3248 
3249 	dludindp->dl_group_address = (pktinfo->isMulticast ||
3250 	    pktinfo->isBroadcast);
3251 
3252 	nmp->b_wptr = nmp->b_rptr + dludindp->dl_dest_addr_offset;
3253 
3254 	mac_copy(pktinfo->dhost, nmp->b_wptr, macinfo->gldm_addrlen);
3255 	nmp->b_wptr += macinfo->gldm_addrlen;
3256 
3257 	ASSERT(macinfo->gldm_saplen == -2);	/* XXX following code assumes */
3258 	*(ushort_t *)(nmp->b_wptr) = type;
3259 	nmp->b_wptr += abs(macinfo->gldm_saplen);
3260 
3261 	ASSERT(nmp->b_wptr == nmp->b_rptr + dludindp->dl_src_addr_offset);
3262 
3263 	mac_copy(pktinfo->shost, nmp->b_wptr, macinfo->gldm_addrlen);
3264 	nmp->b_wptr += macinfo->gldm_addrlen;
3265 
3266 	*(ushort_t *)(nmp->b_wptr) = type;
3267 	nmp->b_wptr += abs(macinfo->gldm_saplen);
3268 
3269 	if (pktinfo->nosource)
3270 		dludindp->dl_src_addr_offset = dludindp->dl_src_addr_length = 0;
3271 	linkb(nmp, mp);
3272 	return (nmp);
3273 }
3274 
3275 /* ======================================================= */
3276 /* wsrv group: called from wsrv, single threaded per queue */
3277 /* ======================================================= */
3278 
3279 /*
3280  * We go to some trouble to avoid taking the same lock during normal
3281  * transmit processing as we do during normal receive processing.
3282  *
3283  * Elements of the per-instance macinfo and per-stream gld_t structures
3284  * are for the most part protected by the GLDM_LOCK rwlock/mutex.
3285  * (Elements of the gld_mac_pvt_t structure are considered part of the
3286  * macinfo structure for purposes of this discussion).
3287  *
3288  * However, it is more complicated than that:
3289  *
3290  *	Elements of the macinfo structure that are set before the macinfo
3291  *	structure is added to its device list by gld_register(), and never
3292  *	thereafter modified, are accessed without requiring taking the lock.
3293  *	A similar rule applies to those elements of the gld_t structure that
3294  *	are written by gld_open() before the stream is added to any list.
3295  *
3296  *	Most other elements of the macinfo structure may only be read or
3297  *	written while holding the maclock.
3298  *
3299  *	Most writable elements of the gld_t structure are written only
3300  *	within the single-threaded domain of wsrv() and subsidiaries.
3301  *	(This domain includes open/close while qprocs are not on.)
3302  *	The maclock need not be taken while within that domain
3303  *	simply to read those elements.  Writing to them, even within
3304  *	that domain, or reading from it outside that domain, requires
3305  *	holding the maclock.  Exception:  if the stream is not
3306  *	presently attached to a PPA, there is no associated macinfo,
3307  *	and no maclock need be taken.
3308  *
3309  *	The curr_macaddr element of the mac private structure is also
3310  *      protected by the GLDM_LOCK rwlock/mutex, like most other members
3311  *      of that structure. However, there are a few instances in the
3312  *      transmit path where we choose to forgo lock protection when
3313  *      reading this variable. This is to avoid lock contention between
3314  *      threads executing the DL_UNITDATA_REQ case and receive threads.
3315  *      In doing so we will take a small risk or a few corrupted packets
3316  *      during the short an rare times when someone is changing the interface's
3317  *      physical address. We consider the small cost in this rare case to be
3318  *      worth the benefit of reduced lock contention under normal operating
3319  *      conditions. The risk/cost is small because:
3320  *          1. there is no guarantee at this layer of uncorrupted delivery.
3321  *          2. the physaddr doesn't change very often - no performance hit.
3322  *          3. if the physaddr changes, other stuff is going to be screwed
3323  *             up for a while anyway, while other sites refigure ARP, etc.,
3324  *             so losing a couple of packets is the least of our worries.
3325  *
3326  *	The list of streams associated with a macinfo is protected by
3327  *	two locks:  the per-macinfo maclock, and the per-major-device
3328  *	gld_devlock.  Both must be held to modify the list, but either
3329  *	may be held to protect the list during reading/traversing.  This
3330  *	allows independent locking for multiple instances in the receive
3331  *	path (using macinfo), while facilitating routines that must search
3332  *	the entire set of streams associated with a major device, such as
3333  *	gld_findminor(), gld_finddevinfo(), close().  The "nstreams"
3334  *	macinfo	element, and the gld_mac_info gld_t element, are similarly
3335  *	protected, since they change at exactly the same time macinfo
3336  *	streams list does.
3337  *
3338  *	The list of macinfo structures associated with a major device
3339  *	structure is protected by the gld_devlock, as is the per-major
3340  *	list of Style 2 streams in the DL_UNATTACHED state.
3341  *
3342  *	The list of major devices is kept on a module-global list
3343  *	gld_device_list, which has its own lock to protect the list.
3344  *
3345  *	When it is necessary to hold more than one lock at a time, they
3346  *	are acquired in this "outside in" order:
3347  *		gld_device_list.gld_devlock
3348  *		glddev->gld_devlock
3349  *		GLDM_LOCK(macinfo)
3350  *
3351  *	Finally, there are some "volatile" elements of the gld_t structure
3352  *	used for synchronization between various routines that don't share
3353  *	the same mutexes.  See the routines for details.  These are:
3354  *		gld_xwait	between gld_wsrv() and gld_sched()
3355  *		gld_sched_ran	between gld_wsrv() and gld_sched()
3356  *		gld_in_unbind	between gld_wput() and wsrv's gld_unbind()
3357  *		gld_wput_count	between gld_wput() and wsrv's gld_unbind()
3358  *		gld_in_wsrv	between gld_wput() and gld_wsrv()
3359  *				(used in conjunction with q->q_first)
3360  */
3361 
3362 /*
3363  * gld_ioctl (q, mp)
3364  * handles all ioctl requests passed downstream. This routine is
3365  * passed a pointer to the message block with the ioctl request in it, and a
3366  * pointer to the queue so it can respond to the ioctl request with an ack.
3367  */
3368 int
3369 gld_ioctl(queue_t *q, mblk_t *mp)
3370 {
3371 	struct iocblk *iocp;
3372 	gld_t *gld;
3373 	gld_mac_info_t *macinfo;
3374 
3375 #ifdef GLD_DEBUG
3376 	if (gld_debug & GLDTRACE)
3377 		cmn_err(CE_NOTE, "gld_ioctl(%p %p)", (void *)q, (void *)mp);
3378 #endif
3379 	gld = (gld_t *)q->q_ptr;
3380 	iocp = (struct iocblk *)mp->b_rptr;
3381 	switch (iocp->ioc_cmd) {
3382 	case DLIOCRAW:		/* raw M_DATA mode */
3383 		gld->gld_flags |= GLD_RAW;
3384 		DB_TYPE(mp) = M_IOCACK;
3385 		qreply(q, mp);
3386 		break;
3387 
3388 	case DL_IOC_HDR_INFO:	/* fastpath */
3389 		/*
3390 		 * DL_IOC_HDR_INFO should only come from IP. The one
3391 		 * initiated from user-land should not be allowed.
3392 		 */
3393 		if ((gld_global_options & GLD_OPT_NO_FASTPATH) ||
3394 		    (iocp->ioc_cr != kcred)) {
3395 			miocnak(q, mp, 0, EINVAL);
3396 			break;
3397 		}
3398 		gld_fastpath(gld, q, mp);
3399 		break;
3400 
3401 	case DLIOCMARGININFO: {	/* margin size */
3402 		int err;
3403 
3404 		if ((macinfo = gld->gld_mac_info) == NULL) {
3405 			miocnak(q, mp, 0, EINVAL);
3406 			break;
3407 		}
3408 
3409 		if ((err = miocpullup(mp, sizeof (uint32_t))) != 0) {
3410 			miocnak(q, mp, 0, err);
3411 			break;
3412 		}
3413 
3414 		*((uint32_t *)mp->b_cont->b_rptr) = macinfo->gldm_margin;
3415 		miocack(q, mp, sizeof (uint32_t), 0);
3416 		break;
3417 	}
3418 	default:
3419 		macinfo	 = gld->gld_mac_info;
3420 		if (macinfo == NULL || macinfo->gldm_ioctl == NULL) {
3421 			miocnak(q, mp, 0, EINVAL);
3422 			break;
3423 		}
3424 
3425 		GLDM_LOCK(macinfo, RW_WRITER);
3426 		(void) (*macinfo->gldm_ioctl) (macinfo, q, mp);
3427 		GLDM_UNLOCK(macinfo);
3428 		break;
3429 	}
3430 	return (0);
3431 }
3432 
3433 /*
3434  * Since the rules for "fastpath" mode don't seem to be documented
3435  * anywhere, I will describe GLD's rules for fastpath users here:
3436  *
3437  * Once in this mode you remain there until close.
3438  * If you unbind/rebind you should get a new header using DL_IOC_HDR_INFO.
3439  * You must be bound (DL_IDLE) to transmit.
3440  * There are other rules not listed above.
3441  */
3442 static void
3443 gld_fastpath(gld_t *gld, queue_t *q, mblk_t *mp)
3444 {
3445 	gld_interface_t *ifp;
3446 	gld_mac_info_t *macinfo;
3447 	dl_unitdata_req_t *dludp;
3448 	mblk_t *nmp;
3449 	t_scalar_t off, len;
3450 	uint_t maclen;
3451 	int error;
3452 
3453 	if (gld->gld_state != DL_IDLE) {
3454 		miocnak(q, mp, 0, EINVAL);
3455 		return;
3456 	}
3457 
3458 	macinfo = gld->gld_mac_info;
3459 	ASSERT(macinfo != NULL);
3460 	maclen = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen);
3461 
3462 	error = miocpullup(mp, sizeof (dl_unitdata_req_t) + maclen);
3463 	if (error != 0) {
3464 		miocnak(q, mp, 0, error);
3465 		return;
3466 	}
3467 
3468 	dludp = (dl_unitdata_req_t *)mp->b_cont->b_rptr;
3469 	off = dludp->dl_dest_addr_offset;
3470 	len = dludp->dl_dest_addr_length;
3471 	if (dludp->dl_primitive != DL_UNITDATA_REQ ||
3472 	    !MBLKIN(mp->b_cont, off, len) || len != maclen) {
3473 		miocnak(q, mp, 0, EINVAL);
3474 		return;
3475 	}
3476 
3477 	/*
3478 	 * We take his fastpath request as a declaration that he will accept
3479 	 * M_DATA messages from us, whether or not we are willing to accept
3480 	 * them from him.  This allows us to have fastpath in one direction
3481 	 * (flow upstream) even on media with Source Routing, where we are
3482 	 * unable to provide a fixed MAC header to be prepended to downstream
3483 	 * flowing packets.  So we set GLD_FAST whether or not we decide to
3484 	 * allow him to send M_DATA down to us.
3485 	 */
3486 	GLDM_LOCK(macinfo, RW_WRITER);
3487 	gld->gld_flags |= GLD_FAST;
3488 	GLDM_UNLOCK(macinfo);
3489 
3490 	ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep;
3491 
3492 	/* This will fail for Source Routing media */
3493 	/* Also on Ethernet on 802.2 SAPs */
3494 	if ((nmp = (*ifp->mkfastpath)(gld, mp)) == NULL) {
3495 		miocnak(q, mp, 0, ENOMEM);
3496 		return;
3497 	}
3498 
3499 	/*
3500 	 * Link new mblk in after the "request" mblks.
3501 	 */
3502 	linkb(mp, nmp);
3503 	miocack(q, mp, msgdsize(mp->b_cont), 0);
3504 }
3505 
3506 /*
3507  * gld_cmds (q, mp)
3508  *	process the DL commands as defined in dlpi.h
3509  *	note that the primitives return status which is passed back
3510  *	to the service procedure.  If the value is GLDE_RETRY, then
3511  *	it is assumed that processing must stop and the primitive has
3512  *	been put back onto the queue.  If the value is any other error,
3513  *	then an error ack is generated by the service procedure.
3514  */
3515 static int
3516 gld_cmds(queue_t *q, mblk_t *mp)
3517 {
3518 	union DL_primitives *dlp = (union DL_primitives *)mp->b_rptr;
3519 	gld_t *gld = (gld_t *)(q->q_ptr);
3520 	int result = DL_BADPRIM;
3521 	int mblkl = MBLKL(mp);
3522 	t_uscalar_t dlreq;
3523 
3524 	/* Make sure we have at least dlp->dl_primitive */
3525 	if (mblkl < sizeof (dlp->dl_primitive))
3526 		return (DL_BADPRIM);
3527 
3528 	dlreq = dlp->dl_primitive;
3529 #ifdef	GLD_DEBUG
3530 	if (gld_debug & GLDTRACE)
3531 		cmn_err(CE_NOTE,
3532 		    "gld_cmds(%p, %p):dlp=%p, dlp->dl_primitive=%d",
3533 		    (void *)q, (void *)mp, (void *)dlp, dlreq);
3534 #endif
3535 
3536 	switch (dlreq) {
3537 	case DL_UDQOS_REQ:
3538 		if (mblkl < DL_UDQOS_REQ_SIZE)
3539 			break;
3540 		result = gld_udqos(q, mp);
3541 		break;
3542 
3543 	case DL_BIND_REQ:
3544 		if (mblkl < DL_BIND_REQ_SIZE)
3545 			break;
3546 		result = gld_bind(q, mp);
3547 		break;
3548 
3549 	case DL_UNBIND_REQ:
3550 		if (mblkl < DL_UNBIND_REQ_SIZE)
3551 			break;
3552 		result = gld_unbind(q, mp);
3553 		break;
3554 
3555 	case DL_UNITDATA_REQ:
3556 		if (mblkl < DL_UNITDATA_REQ_SIZE)
3557 			break;
3558 		result = gld_unitdata(q, mp);
3559 		break;
3560 
3561 	case DL_INFO_REQ:
3562 		if (mblkl < DL_INFO_REQ_SIZE)
3563 			break;
3564 		result = gld_inforeq(q, mp);
3565 		break;
3566 
3567 	case DL_ATTACH_REQ:
3568 		if (mblkl < DL_ATTACH_REQ_SIZE)
3569 			break;
3570 		if (gld->gld_style == DL_STYLE2)
3571 			result = gldattach(q, mp);
3572 		else
3573 			result = DL_NOTSUPPORTED;
3574 		break;
3575 
3576 	case DL_DETACH_REQ:
3577 		if (mblkl < DL_DETACH_REQ_SIZE)
3578 			break;
3579 		if (gld->gld_style == DL_STYLE2)
3580 			result = gldunattach(q, mp);
3581 		else
3582 			result = DL_NOTSUPPORTED;
3583 		break;
3584 
3585 	case DL_ENABMULTI_REQ:
3586 		if (mblkl < DL_ENABMULTI_REQ_SIZE)
3587 			break;
3588 		result = gld_enable_multi(q, mp);
3589 		break;
3590 
3591 	case DL_DISABMULTI_REQ:
3592 		if (mblkl < DL_DISABMULTI_REQ_SIZE)
3593 			break;
3594 		result = gld_disable_multi(q, mp);
3595 		break;
3596 
3597 	case DL_PHYS_ADDR_REQ:
3598 		if (mblkl < DL_PHYS_ADDR_REQ_SIZE)
3599 			break;
3600 		result = gld_physaddr(q, mp);
3601 		break;
3602 
3603 	case DL_SET_PHYS_ADDR_REQ:
3604 		if (mblkl < DL_SET_PHYS_ADDR_REQ_SIZE)
3605 			break;
3606 		result = gld_setaddr(q, mp);
3607 		break;
3608 
3609 	case DL_PROMISCON_REQ:
3610 		if (mblkl < DL_PROMISCON_REQ_SIZE)
3611 			break;
3612 		result = gld_promisc(q, mp, dlreq, B_TRUE);
3613 		break;
3614 
3615 	case DL_PROMISCOFF_REQ:
3616 		if (mblkl < DL_PROMISCOFF_REQ_SIZE)
3617 			break;
3618 		result = gld_promisc(q, mp, dlreq, B_FALSE);
3619 		break;
3620 
3621 	case DL_GET_STATISTICS_REQ:
3622 		if (mblkl < DL_GET_STATISTICS_REQ_SIZE)
3623 			break;
3624 		result = gld_get_statistics(q, mp);
3625 		break;
3626 
3627 	case DL_CAPABILITY_REQ:
3628 		if (mblkl < DL_CAPABILITY_REQ_SIZE)
3629 			break;
3630 		result = gld_cap(q, mp);
3631 		break;
3632 
3633 	case DL_NOTIFY_REQ:
3634 		if (mblkl < DL_NOTIFY_REQ_SIZE)
3635 			break;
3636 		result = gld_notify_req(q, mp);
3637 		break;
3638 
3639 	case DL_XID_REQ:
3640 	case DL_XID_RES:
3641 	case DL_TEST_REQ:
3642 	case DL_TEST_RES:
3643 	case DL_CONTROL_REQ:
3644 	case DL_PASSIVE_REQ:
3645 		result = DL_NOTSUPPORTED;
3646 		break;
3647 
3648 	default:
3649 #ifdef	GLD_DEBUG
3650 		if (gld_debug & GLDERRS)
3651 			cmn_err(CE_WARN,
3652 			    "gld_cmds: unknown M_PROTO message: %d",
3653 			    dlreq);
3654 #endif
3655 		result = DL_BADPRIM;
3656 	}
3657 
3658 	return (result);
3659 }
3660 
3661 static int
3662 gld_cap(queue_t *q, mblk_t *mp)
3663 {
3664 	gld_t *gld = (gld_t *)q->q_ptr;
3665 	dl_capability_req_t *dlp = (dl_capability_req_t *)mp->b_rptr;
3666 
3667 	if (gld->gld_state == DL_UNATTACHED)
3668 		return (DL_OUTSTATE);
3669 
3670 	if (dlp->dl_sub_length == 0)
3671 		return (gld_cap_ack(q, mp));
3672 
3673 	return (gld_cap_enable(q, mp));
3674 }
3675 
3676 static int
3677 gld_cap_ack(queue_t *q, mblk_t *mp)
3678 {
3679 	gld_t *gld = (gld_t *)q->q_ptr;
3680 	gld_mac_info_t *macinfo = gld->gld_mac_info;
3681 	gld_interface_t *ifp;
3682 	dl_capability_ack_t *dlap;
3683 	dl_capability_sub_t *dlsp;
3684 	size_t size = sizeof (dl_capability_ack_t);
3685 	size_t subsize = 0;
3686 
3687 	ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep;
3688 
3689 	if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_ANY)
3690 		subsize += sizeof (dl_capability_sub_t) +
3691 		    sizeof (dl_capab_hcksum_t);
3692 	if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY)
3693 		subsize += sizeof (dl_capability_sub_t) +
3694 		    sizeof (dl_capab_zerocopy_t);
3695 	if (macinfo->gldm_options & GLDOPT_MDT)
3696 		subsize += (sizeof (dl_capability_sub_t) +
3697 		    sizeof (dl_capab_mdt_t));
3698 
3699 	if ((mp = mexchange(q, mp, size + subsize, M_PROTO,
3700 	    DL_CAPABILITY_ACK)) == NULL)
3701 		return (GLDE_OK);
3702 
3703 	dlap = (dl_capability_ack_t *)mp->b_rptr;
3704 	dlap->dl_sub_offset = 0;
3705 	if ((dlap->dl_sub_length = subsize) != 0)
3706 		dlap->dl_sub_offset = sizeof (dl_capability_ack_t);
3707 	dlsp = (dl_capability_sub_t *)&dlap[1];
3708 
3709 	if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_ANY) {
3710 		dl_capab_hcksum_t *dlhp = (dl_capab_hcksum_t *)&dlsp[1];
3711 
3712 		dlsp->dl_cap = DL_CAPAB_HCKSUM;
3713 		dlsp->dl_length = sizeof (dl_capab_hcksum_t);
3714 
3715 		dlhp->hcksum_version = HCKSUM_VERSION_1;
3716 
3717 		dlhp->hcksum_txflags = 0;
3718 		if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_PARTIAL)
3719 			dlhp->hcksum_txflags |= HCKSUM_INET_PARTIAL;
3720 		if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_FULL_V4)
3721 			dlhp->hcksum_txflags |= HCKSUM_INET_FULL_V4;
3722 		if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_FULL_V6)
3723 			dlhp->hcksum_txflags |= HCKSUM_INET_FULL_V6;
3724 		if (macinfo->gldm_capabilities & GLD_CAP_CKSUM_IPHDR)
3725 			dlhp->hcksum_txflags |= HCKSUM_IPHDRCKSUM;
3726 
3727 		dlcapabsetqid(&(dlhp->hcksum_mid), RD(q));
3728 		dlsp = (dl_capability_sub_t *)&dlhp[1];
3729 	}
3730 
3731 	if (macinfo->gldm_capabilities & GLD_CAP_ZEROCOPY) {
3732 		dl_capab_zerocopy_t *dlzp = (dl_capab_zerocopy_t *)&dlsp[1];
3733 
3734 		dlsp->dl_cap = DL_CAPAB_ZEROCOPY;
3735 		dlsp->dl_length = sizeof (dl_capab_zerocopy_t);
3736 		dlzp->zerocopy_version = ZEROCOPY_VERSION_1;
3737 		dlzp->zerocopy_flags = DL_CAPAB_VMSAFE_MEM;
3738 
3739 		dlcapabsetqid(&(dlzp->zerocopy_mid), RD(q));
3740 		dlsp = (dl_capability_sub_t *)&dlzp[1];
3741 	}
3742 
3743 	if (macinfo->gldm_options & GLDOPT_MDT) {
3744 		dl_capab_mdt_t *dlmp = (dl_capab_mdt_t *)&dlsp[1];
3745 
3746 		dlsp->dl_cap = DL_CAPAB_MDT;
3747 		dlsp->dl_length = sizeof (dl_capab_mdt_t);
3748 
3749 		dlmp->mdt_version = MDT_VERSION_2;
3750 		dlmp->mdt_max_pld = macinfo->gldm_mdt_segs;
3751 		dlmp->mdt_span_limit = macinfo->gldm_mdt_sgl;
3752 		dlcapabsetqid(&dlmp->mdt_mid, OTHERQ(q));
3753 		dlmp->mdt_flags = DL_CAPAB_MDT_ENABLE;
3754 		dlmp->mdt_hdr_head = ifp->hdr_size;
3755 		dlmp->mdt_hdr_tail = 0;
3756 	}
3757 
3758 	qreply(q, mp);
3759 	return (GLDE_OK);
3760 }
3761 
3762 static int
3763 gld_cap_enable(queue_t *q, mblk_t *mp)
3764 {
3765 	dl_capability_req_t *dlp;
3766 	dl_capability_sub_t *dlsp;
3767 	dl_capab_hcksum_t *dlhp;
3768 	offset_t off;
3769 	size_t len;
3770 	size_t size;
3771 	offset_t end;
3772 
3773 	dlp = (dl_capability_req_t *)mp->b_rptr;
3774 	dlp->dl_primitive = DL_CAPABILITY_ACK;
3775 
3776 	off = dlp->dl_sub_offset;
3777 	len = dlp->dl_sub_length;
3778 
3779 	if (!MBLKIN(mp, off, len))
3780 		return (DL_BADPRIM);
3781 
3782 	end = off + len;
3783 	while (off < end) {
3784 		dlsp = (dl_capability_sub_t *)(mp->b_rptr + off);
3785 		size = sizeof (dl_capability_sub_t) + dlsp->dl_length;
3786 		if (off + size > end)
3787 			return (DL_BADPRIM);
3788 
3789 		switch (dlsp->dl_cap) {
3790 		case DL_CAPAB_HCKSUM:
3791 			dlhp = (dl_capab_hcksum_t *)&dlsp[1];
3792 			/* nothing useful we can do with the contents */
3793 			dlcapabsetqid(&(dlhp->hcksum_mid), RD(q));
3794 			break;
3795 		default:
3796 			break;
3797 		}
3798 
3799 		off += size;
3800 	}
3801 
3802 	qreply(q, mp);
3803 	return (GLDE_OK);
3804 }
3805 
3806 /*
3807  * Send a copy of the DL_NOTIFY_IND message <mp> to each stream that has
3808  * requested the specific <notification> that the message carries AND is
3809  * eligible and ready to receive the notification immediately.
3810  *
3811  * This routine ignores flow control. Notifications will be sent regardless.
3812  *
3813  * In all cases, the original message passed in is freed at the end of
3814  * the routine.
3815  */
3816 static void
3817 gld_notify_qs(gld_mac_info_t *macinfo, mblk_t *mp, uint32_t notification)
3818 {
3819 	gld_mac_pvt_t *mac_pvt;
3820 	gld_vlan_t *vlan;
3821 	gld_t *gld;
3822 	mblk_t *nmp;
3823 	int i;
3824 
3825 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
3826 
3827 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
3828 
3829 	/*
3830 	 * Search all the streams attached to this macinfo looking
3831 	 * for those eligible to receive the present notification.
3832 	 */
3833 	for (i = 0; i < VLAN_HASHSZ; i++) {
3834 		for (vlan = mac_pvt->vlan_hash[i];
3835 		    vlan != NULL; vlan = vlan->gldv_next) {
3836 			for (gld = vlan->gldv_str_next;
3837 			    gld != (gld_t *)&vlan->gldv_str_next;
3838 			    gld = gld->gld_next) {
3839 				ASSERT(gld->gld_qptr != NULL);
3840 				ASSERT(gld->gld_state == DL_IDLE ||
3841 				    gld->gld_state == DL_UNBOUND);
3842 				ASSERT(gld->gld_mac_info == macinfo);
3843 
3844 				if (gld->gld_flags & GLD_STR_CLOSING)
3845 					continue; /* not eligible - skip */
3846 				if (!(notification & gld->gld_notifications))
3847 					continue; /* not wanted - skip */
3848 				if ((nmp = dupmsg(mp)) == NULL)
3849 					continue; /* can't copy - skip */
3850 
3851 				/*
3852 				 * All OK; send dup'd notification up this
3853 				 * stream
3854 				 */
3855 				qreply(WR(gld->gld_qptr), nmp);
3856 			}
3857 		}
3858 	}
3859 
3860 	/*
3861 	 * Drop the original message block now
3862 	 */
3863 	freemsg(mp);
3864 }
3865 
3866 /*
3867  * For each (understood) bit in the <notifications> argument, contruct
3868  * a DL_NOTIFY_IND message and send it to the specified <q>, or to all
3869  * eligible queues if <q> is NULL.
3870  */
3871 static void
3872 gld_notify_ind(gld_mac_info_t *macinfo, uint32_t notifications, queue_t *q)
3873 {
3874 	gld_mac_pvt_t *mac_pvt;
3875 	dl_notify_ind_t *dlnip;
3876 	struct gld_stats *stats;
3877 	mblk_t *mp;
3878 	size_t size;
3879 	uint32_t bit;
3880 
3881 	GLDM_LOCK(macinfo, RW_WRITER);
3882 
3883 	/*
3884 	 * The following cases shouldn't happen, but just in case the
3885 	 * MAC driver calls gld_linkstate() at an inappropriate time, we
3886 	 * check anyway ...
3887 	 */
3888 	if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY)) {
3889 		GLDM_UNLOCK(macinfo);
3890 		return;				/* not ready yet	*/
3891 	}
3892 
3893 	if (macinfo->gldm_GLD_flags & GLD_UNREGISTERED) {
3894 		GLDM_UNLOCK(macinfo);
3895 		return;				/* not ready anymore	*/
3896 	}
3897 
3898 	/*
3899 	 * Make sure the kstats are up to date, 'cos we use some of
3900 	 * the kstat values below, specifically the link speed ...
3901 	 */
3902 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
3903 	stats = mac_pvt->statistics;
3904 	if (macinfo->gldm_get_stats)
3905 		(void) (*macinfo->gldm_get_stats)(macinfo, stats);
3906 
3907 	for (bit = 1; notifications != 0; bit <<= 1) {
3908 		if ((notifications & bit) == 0)
3909 			continue;
3910 		notifications &= ~bit;
3911 
3912 		size = DL_NOTIFY_IND_SIZE;
3913 		if (bit == DL_NOTE_PHYS_ADDR)
3914 			size += macinfo->gldm_addrlen;
3915 		if ((mp = allocb(size, BPRI_MED)) == NULL)
3916 			continue;
3917 
3918 		mp->b_datap->db_type = M_PROTO;
3919 		mp->b_wptr = mp->b_rptr + size;
3920 		dlnip = (dl_notify_ind_t *)mp->b_rptr;
3921 		dlnip->dl_primitive = DL_NOTIFY_IND;
3922 		dlnip->dl_notification = 0;
3923 		dlnip->dl_data = 0;
3924 		dlnip->dl_addr_length = 0;
3925 		dlnip->dl_addr_offset = 0;
3926 
3927 		switch (bit) {
3928 		case DL_NOTE_PROMISC_ON_PHYS:
3929 		case DL_NOTE_PROMISC_OFF_PHYS:
3930 			if (mac_pvt->nprom != 0)
3931 				dlnip->dl_notification = bit;
3932 			break;
3933 
3934 		case DL_NOTE_LINK_DOWN:
3935 			if (macinfo->gldm_linkstate == GLD_LINKSTATE_DOWN)
3936 				dlnip->dl_notification = bit;
3937 			break;
3938 
3939 		case DL_NOTE_LINK_UP:
3940 			if (macinfo->gldm_linkstate == GLD_LINKSTATE_UP)
3941 				dlnip->dl_notification = bit;
3942 			break;
3943 
3944 		case DL_NOTE_SPEED:
3945 			/*
3946 			 * Conversion required here:
3947 			 *	GLD keeps the speed in bit/s in a uint64
3948 			 *	DLPI wants it in kb/s in a uint32
3949 			 * Fortunately this is still big enough for 10Gb/s!
3950 			 */
3951 			dlnip->dl_notification = bit;
3952 			dlnip->dl_data = stats->glds_speed/1000ULL;
3953 			break;
3954 
3955 		case DL_NOTE_PHYS_ADDR:
3956 			dlnip->dl_notification = bit;
3957 			dlnip->dl_data = DL_CURR_PHYS_ADDR;
3958 			dlnip->dl_addr_offset = sizeof (dl_notify_ind_t);
3959 			dlnip->dl_addr_length = macinfo->gldm_addrlen +
3960 			    abs(macinfo->gldm_saplen);
3961 			mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
3962 			mac_copy(mac_pvt->curr_macaddr,
3963 			    mp->b_rptr + sizeof (dl_notify_ind_t),
3964 			    macinfo->gldm_addrlen);
3965 			break;
3966 
3967 		default:
3968 			break;
3969 		}
3970 
3971 		if (dlnip->dl_notification == 0)
3972 			freemsg(mp);
3973 		else if (q != NULL)
3974 			qreply(q, mp);
3975 		else
3976 			gld_notify_qs(macinfo, mp, bit);
3977 	}
3978 
3979 	GLDM_UNLOCK(macinfo);
3980 }
3981 
3982 /*
3983  * gld_notify_req - handle a DL_NOTIFY_REQ message
3984  */
3985 static int
3986 gld_notify_req(queue_t *q, mblk_t *mp)
3987 {
3988 	gld_t *gld = (gld_t *)q->q_ptr;
3989 	gld_mac_info_t *macinfo;
3990 	gld_mac_pvt_t *pvt;
3991 	dl_notify_req_t *dlnrp;
3992 	dl_notify_ack_t *dlnap;
3993 
3994 	ASSERT(gld != NULL);
3995 	ASSERT(gld->gld_qptr == RD(q));
3996 
3997 	dlnrp = (dl_notify_req_t *)mp->b_rptr;
3998 
3999 #ifdef GLD_DEBUG
4000 	if (gld_debug & GLDTRACE)
4001 		cmn_err(CE_NOTE, "gld_notify_req(%p %p)",
4002 		    (void *)q, (void *)mp);
4003 #endif
4004 
4005 	if (gld->gld_state == DL_UNATTACHED) {
4006 #ifdef GLD_DEBUG
4007 		if (gld_debug & GLDERRS)
4008 			cmn_err(CE_NOTE, "gld_notify_req: wrong state (%d)",
4009 			    gld->gld_state);
4010 #endif
4011 		return (DL_OUTSTATE);
4012 	}
4013 
4014 	/*
4015 	 * Remember what notifications are required by this stream
4016 	 */
4017 	macinfo = gld->gld_mac_info;
4018 	pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4019 
4020 	gld->gld_notifications = dlnrp->dl_notifications & pvt->notifications;
4021 
4022 	/*
4023 	 * The return DL_NOTIFY_ACK carries the bitset of notifications
4024 	 * that this driver can provide, independently of which ones have
4025 	 * previously been or are now being requested.
4026 	 */
4027 	if ((mp = mexchange(q, mp, sizeof (dl_notify_ack_t), M_PCPROTO,
4028 	    DL_NOTIFY_ACK)) == NULL)
4029 		return (DL_SYSERR);
4030 
4031 	dlnap = (dl_notify_ack_t *)mp->b_rptr;
4032 	dlnap->dl_notifications = pvt->notifications;
4033 	qreply(q, mp);
4034 
4035 	/*
4036 	 * A side effect of a DL_NOTIFY_REQ is that after the DL_NOTIFY_ACK
4037 	 * reply, the the requestor gets zero or more DL_NOTIFY_IND messages
4038 	 * that provide the current status.
4039 	 */
4040 	gld_notify_ind(macinfo, gld->gld_notifications, q);
4041 
4042 	return (GLDE_OK);
4043 }
4044 
4045 /*
4046  * gld_linkstate()
4047  *	Called by driver to tell GLD the state of the physical link.
4048  *	As a side effect, sends a DL_NOTE_LINK_UP or DL_NOTE_LINK_DOWN
4049  *	notification to each client that has previously requested such
4050  *	notifications
4051  */
4052 void
4053 gld_linkstate(gld_mac_info_t *macinfo, int32_t newstate)
4054 {
4055 	uint32_t notification;
4056 
4057 	switch (newstate) {
4058 	default:
4059 		return;
4060 
4061 	case GLD_LINKSTATE_DOWN:
4062 		notification = DL_NOTE_LINK_DOWN;
4063 		break;
4064 
4065 	case GLD_LINKSTATE_UP:
4066 		notification = DL_NOTE_LINK_UP | DL_NOTE_SPEED;
4067 		break;
4068 
4069 	case GLD_LINKSTATE_UNKNOWN:
4070 		notification = 0;
4071 		break;
4072 	}
4073 
4074 	GLDM_LOCK(macinfo, RW_WRITER);
4075 	if (macinfo->gldm_linkstate == newstate)
4076 		notification = 0;
4077 	else
4078 		macinfo->gldm_linkstate = newstate;
4079 	GLDM_UNLOCK(macinfo);
4080 
4081 	if (notification)
4082 		gld_notify_ind(macinfo, notification, NULL);
4083 }
4084 
4085 /*
4086  * gld_udqos - set the current QoS parameters (priority only at the moment).
4087  */
4088 static int
4089 gld_udqos(queue_t *q, mblk_t *mp)
4090 {
4091 	dl_udqos_req_t *dlp;
4092 	gld_t  *gld = (gld_t *)q->q_ptr;
4093 	int off;
4094 	int len;
4095 	dl_qos_cl_sel1_t *selp;
4096 
4097 	ASSERT(gld);
4098 	ASSERT(gld->gld_qptr == RD(q));
4099 
4100 #ifdef GLD_DEBUG
4101 	if (gld_debug & GLDTRACE)
4102 		cmn_err(CE_NOTE, "gld_udqos(%p %p)", (void *)q, (void *)mp);
4103 #endif
4104 
4105 	if (gld->gld_state != DL_IDLE) {
4106 #ifdef GLD_DEBUG
4107 		if (gld_debug & GLDERRS)
4108 			cmn_err(CE_NOTE, "gld_udqos: wrong state (%d)",
4109 			    gld->gld_state);
4110 #endif
4111 		return (DL_OUTSTATE);
4112 	}
4113 
4114 	dlp = (dl_udqos_req_t *)mp->b_rptr;
4115 	off = dlp->dl_qos_offset;
4116 	len = dlp->dl_qos_length;
4117 
4118 	if (len != sizeof (dl_qos_cl_sel1_t) || !MBLKIN(mp, off, len))
4119 		return (DL_BADQOSTYPE);
4120 
4121 	selp = (dl_qos_cl_sel1_t *)(mp->b_rptr + off);
4122 	if (selp->dl_qos_type != DL_QOS_CL_SEL1)
4123 		return (DL_BADQOSTYPE);
4124 
4125 	if (selp->dl_trans_delay != 0 &&
4126 	    selp->dl_trans_delay != DL_QOS_DONT_CARE)
4127 		return (DL_BADQOSPARAM);
4128 	if (selp->dl_protection != 0 &&
4129 	    selp->dl_protection != DL_QOS_DONT_CARE)
4130 		return (DL_BADQOSPARAM);
4131 	if (selp->dl_residual_error != 0 &&
4132 	    selp->dl_residual_error != DL_QOS_DONT_CARE)
4133 		return (DL_BADQOSPARAM);
4134 	if (selp->dl_priority < 0 || selp->dl_priority > 7)
4135 		return (DL_BADQOSPARAM);
4136 
4137 	gld->gld_upri = selp->dl_priority;
4138 
4139 	dlokack(q, mp, DL_UDQOS_REQ);
4140 	return (GLDE_OK);
4141 }
4142 
4143 static mblk_t *
4144 gld_bindack(queue_t *q, mblk_t *mp)
4145 {
4146 	gld_t *gld = (gld_t *)q->q_ptr;
4147 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4148 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4149 	dl_bind_ack_t *dlp;
4150 	size_t size;
4151 	t_uscalar_t addrlen;
4152 	uchar_t *sapp;
4153 
4154 	addrlen = macinfo->gldm_addrlen + abs(macinfo->gldm_saplen);
4155 	size = sizeof (dl_bind_ack_t) + addrlen;
4156 	if ((mp = mexchange(q, mp, size, M_PCPROTO, DL_BIND_ACK)) == NULL)
4157 		return (NULL);
4158 
4159 	dlp = (dl_bind_ack_t *)mp->b_rptr;
4160 	dlp->dl_sap = gld->gld_sap;
4161 	dlp->dl_addr_length = addrlen;
4162 	dlp->dl_addr_offset = sizeof (dl_bind_ack_t);
4163 	dlp->dl_max_conind = 0;
4164 	dlp->dl_xidtest_flg = 0;
4165 
4166 	mac_copy(mac_pvt->curr_macaddr, (uchar_t *)&dlp[1],
4167 	    macinfo->gldm_addrlen);
4168 	sapp = mp->b_rptr + dlp->dl_addr_offset + macinfo->gldm_addrlen;
4169 	*(ushort_t *)sapp = gld->gld_sap;
4170 
4171 	return (mp);
4172 }
4173 
4174 /*
4175  * gld_bind - determine if a SAP is already allocated and whether it is legal
4176  * to do the bind at this time
4177  */
4178 static int
4179 gld_bind(queue_t *q, mblk_t *mp)
4180 {
4181 	ulong_t	sap;
4182 	dl_bind_req_t *dlp;
4183 	gld_t *gld = (gld_t *)q->q_ptr;
4184 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4185 
4186 	ASSERT(gld);
4187 	ASSERT(gld->gld_qptr == RD(q));
4188 
4189 #ifdef GLD_DEBUG
4190 	if (gld_debug & GLDTRACE)
4191 		cmn_err(CE_NOTE, "gld_bind(%p %p)", (void *)q, (void *)mp);
4192 #endif
4193 
4194 	dlp = (dl_bind_req_t *)mp->b_rptr;
4195 	sap = dlp->dl_sap;
4196 
4197 #ifdef GLD_DEBUG
4198 	if (gld_debug & GLDPROT)
4199 		cmn_err(CE_NOTE, "gld_bind: lsap=%lx", sap);
4200 #endif
4201 
4202 	if (gld->gld_state != DL_UNBOUND) {
4203 #ifdef GLD_DEBUG
4204 		if (gld_debug & GLDERRS)
4205 			cmn_err(CE_NOTE, "gld_bind: bound or not attached (%d)",
4206 			    gld->gld_state);
4207 #endif
4208 		return (DL_OUTSTATE);
4209 	}
4210 	ASSERT(macinfo);
4211 
4212 	if (dlp->dl_service_mode != DL_CLDLS) {
4213 		return (DL_UNSUPPORTED);
4214 	}
4215 	if (dlp->dl_xidtest_flg & (DL_AUTO_XID | DL_AUTO_TEST)) {
4216 		return (DL_NOAUTO);
4217 	}
4218 
4219 	/*
4220 	 * Check sap validity and decide whether this stream accepts
4221 	 * IEEE 802.2 (LLC) packets.
4222 	 */
4223 	if (sap > ETHERTYPE_MAX)
4224 		return (DL_BADSAP);
4225 
4226 	/*
4227 	 * Decide whether the SAP value selects EtherType encoding/decoding.
4228 	 * For compatibility with monolithic ethernet drivers, the range of
4229 	 * SAP values is different for DL_ETHER media.
4230 	 */
4231 	switch (macinfo->gldm_type) {
4232 	case DL_ETHER:
4233 		gld->gld_ethertype = (sap > ETHERMTU);
4234 		break;
4235 	default:
4236 		gld->gld_ethertype = (sap > GLD_MAX_802_SAP);
4237 		break;
4238 	}
4239 
4240 	/* if we get to here, then the SAP is legal enough */
4241 	GLDM_LOCK(macinfo, RW_WRITER);
4242 	gld->gld_state = DL_IDLE;	/* bound and ready */
4243 	gld->gld_sap = sap;
4244 	if ((macinfo->gldm_type == DL_ETHER) && (sap == ETHERTYPE_VLAN))
4245 		((gld_vlan_t *)gld->gld_vlan)->gldv_nvlan_sap++;
4246 	gld_set_ipq(gld);
4247 
4248 #ifdef GLD_DEBUG
4249 	if (gld_debug & GLDPROT)
4250 		cmn_err(CE_NOTE, "gld_bind: ok - sap = %d", gld->gld_sap);
4251 #endif
4252 
4253 	/* ACK the BIND */
4254 	mp = gld_bindack(q, mp);
4255 	GLDM_UNLOCK(macinfo);
4256 
4257 	if (mp != NULL) {
4258 		qreply(q, mp);
4259 		return (GLDE_OK);
4260 	}
4261 
4262 	return (DL_SYSERR);
4263 }
4264 
4265 /*
4266  * gld_unbind - perform an unbind of an LSAP or ether type on the stream.
4267  * The stream is still open and can be re-bound.
4268  */
4269 static int
4270 gld_unbind(queue_t *q, mblk_t *mp)
4271 {
4272 	gld_t *gld = (gld_t *)q->q_ptr;
4273 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4274 
4275 	ASSERT(gld);
4276 
4277 #ifdef GLD_DEBUG
4278 	if (gld_debug & GLDTRACE)
4279 		cmn_err(CE_NOTE, "gld_unbind(%p %p)", (void *)q, (void *)mp);
4280 #endif
4281 
4282 	if (gld->gld_state != DL_IDLE) {
4283 #ifdef GLD_DEBUG
4284 		if (gld_debug & GLDERRS)
4285 			cmn_err(CE_NOTE, "gld_unbind: wrong state (%d)",
4286 			    gld->gld_state);
4287 #endif
4288 		return (DL_OUTSTATE);
4289 	}
4290 	ASSERT(macinfo);
4291 
4292 	/*
4293 	 * Avoid unbinding (DL_UNBIND_REQ) while FAST/RAW is inside wput.
4294 	 * See comments above gld_start().
4295 	 */
4296 	gld->gld_in_unbind = B_TRUE;	/* disallow wput=>start */
4297 	membar_enter();
4298 	if (gld->gld_wput_count != 0) {
4299 		gld->gld_in_unbind = B_FALSE;
4300 		ASSERT(mp);		/* we didn't come from close */
4301 #ifdef GLD_DEBUG
4302 		if (gld_debug & GLDETRACE)
4303 			cmn_err(CE_NOTE, "gld_unbind: defer for wput");
4304 #endif
4305 		(void) putbq(q, mp);
4306 		qenable(q);		/* try again soon */
4307 		return (GLDE_RETRY);
4308 	}
4309 
4310 	GLDM_LOCK(macinfo, RW_WRITER);
4311 	if ((macinfo->gldm_type == DL_ETHER) &&
4312 	    (gld->gld_sap == ETHERTYPE_VLAN)) {
4313 		((gld_vlan_t *)gld->gld_vlan)->gldv_nvlan_sap--;
4314 	}
4315 	gld->gld_state = DL_UNBOUND;
4316 	gld->gld_sap = 0;
4317 	gld_set_ipq(gld);
4318 	GLDM_UNLOCK(macinfo);
4319 
4320 	membar_exit();
4321 	gld->gld_in_unbind = B_FALSE;
4322 
4323 	/* mp is NULL if we came from close */
4324 	if (mp) {
4325 		gld_flushqueue(q);	/* flush the queues */
4326 		dlokack(q, mp, DL_UNBIND_REQ);
4327 	}
4328 	return (GLDE_OK);
4329 }
4330 
4331 /*
4332  * gld_inforeq - generate the response to an info request
4333  */
4334 static int
4335 gld_inforeq(queue_t *q, mblk_t *mp)
4336 {
4337 	gld_t		*gld;
4338 	dl_info_ack_t	*dlp;
4339 	int		bufsize;
4340 	glddev_t	*glddev;
4341 	gld_mac_info_t	*macinfo;
4342 	gld_mac_pvt_t	*mac_pvt;
4343 	int		sel_offset = 0;
4344 	int		range_offset = 0;
4345 	int		addr_offset;
4346 	int		addr_length;
4347 	int		sap_length;
4348 	int		brdcst_offset;
4349 	int		brdcst_length;
4350 	uchar_t		*sapp;
4351 
4352 #ifdef GLD_DEBUG
4353 	if (gld_debug & GLDTRACE)
4354 		cmn_err(CE_NOTE, "gld_inforeq(%p %p)", (void *)q, (void *)mp);
4355 #endif
4356 	gld = (gld_t *)q->q_ptr;
4357 	ASSERT(gld);
4358 	glddev = gld->gld_device;
4359 	ASSERT(glddev);
4360 
4361 	if (gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND) {
4362 		macinfo = gld->gld_mac_info;
4363 		ASSERT(macinfo != NULL);
4364 
4365 		mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4366 
4367 		addr_length = macinfo->gldm_addrlen;
4368 		sap_length = macinfo->gldm_saplen;
4369 		brdcst_length = macinfo->gldm_addrlen;
4370 	} else {
4371 		addr_length = glddev->gld_addrlen;
4372 		sap_length = glddev->gld_saplen;
4373 		brdcst_length = glddev->gld_addrlen;
4374 	}
4375 
4376 	bufsize = sizeof (dl_info_ack_t);
4377 
4378 	addr_offset = bufsize;
4379 	bufsize += addr_length;
4380 	bufsize += abs(sap_length);
4381 
4382 	brdcst_offset = bufsize;
4383 	bufsize += brdcst_length;
4384 
4385 	if (((gld_vlan_t *)gld->gld_vlan) != NULL) {
4386 		sel_offset = P2ROUNDUP(bufsize, sizeof (int64_t));
4387 		bufsize = sel_offset + sizeof (dl_qos_cl_sel1_t);
4388 
4389 		range_offset = P2ROUNDUP(bufsize, sizeof (int64_t));
4390 		bufsize = range_offset + sizeof (dl_qos_cl_range1_t);
4391 	}
4392 
4393 	if ((mp = mexchange(q, mp, bufsize, M_PCPROTO, DL_INFO_ACK)) == NULL)
4394 		return (GLDE_OK);	/* nothing more to be done */
4395 
4396 	bzero(mp->b_rptr, bufsize);
4397 
4398 	dlp = (dl_info_ack_t *)mp->b_rptr;
4399 	dlp->dl_primitive = DL_INFO_ACK;
4400 	dlp->dl_version = DL_VERSION_2;
4401 	dlp->dl_service_mode = DL_CLDLS;
4402 	dlp->dl_current_state = gld->gld_state;
4403 	dlp->dl_provider_style = gld->gld_style;
4404 
4405 	if (sel_offset != 0) {
4406 		dl_qos_cl_sel1_t	*selp;
4407 		dl_qos_cl_range1_t	*rangep;
4408 
4409 		ASSERT(range_offset != 0);
4410 
4411 		dlp->dl_qos_offset = sel_offset;
4412 		dlp->dl_qos_length = sizeof (dl_qos_cl_sel1_t);
4413 		dlp->dl_qos_range_offset = range_offset;
4414 		dlp->dl_qos_range_length = sizeof (dl_qos_cl_range1_t);
4415 
4416 		selp = (dl_qos_cl_sel1_t *)(mp->b_rptr + sel_offset);
4417 		selp->dl_qos_type = DL_QOS_CL_SEL1;
4418 		selp->dl_priority = gld->gld_upri;
4419 
4420 		rangep = (dl_qos_cl_range1_t *)(mp->b_rptr + range_offset);
4421 		rangep->dl_qos_type = DL_QOS_CL_RANGE1;
4422 		rangep->dl_priority.dl_min = 0;
4423 		rangep->dl_priority.dl_max = 7;
4424 	}
4425 
4426 	if (gld->gld_state == DL_IDLE || gld->gld_state == DL_UNBOUND) {
4427 		dlp->dl_min_sdu = macinfo->gldm_minpkt;
4428 		dlp->dl_max_sdu = macinfo->gldm_maxpkt;
4429 		dlp->dl_mac_type = macinfo->gldm_type;
4430 		dlp->dl_addr_length = addr_length + abs(sap_length);
4431 		dlp->dl_sap_length = sap_length;
4432 
4433 		if (gld->gld_state == DL_IDLE) {
4434 			/*
4435 			 * If we are bound to a non-LLC SAP on any medium
4436 			 * other than Ethernet, then we need room for a
4437 			 * SNAP header.  So we have to adjust the MTU size
4438 			 * accordingly.  XXX I suppose this should be done
4439 			 * in gldutil.c, but it seems likely that this will
4440 			 * always be true for everything GLD supports but
4441 			 * Ethernet.  Check this if you add another medium.
4442 			 */
4443 			if ((macinfo->gldm_type == DL_TPR ||
4444 			    macinfo->gldm_type == DL_FDDI) &&
4445 			    gld->gld_ethertype)
4446 				dlp->dl_max_sdu -= LLC_SNAP_HDR_LEN;
4447 
4448 			/* copy macaddr and sap */
4449 			dlp->dl_addr_offset = addr_offset;
4450 
4451 			mac_copy(mac_pvt->curr_macaddr, mp->b_rptr +
4452 			    addr_offset, macinfo->gldm_addrlen);
4453 			sapp = mp->b_rptr + addr_offset +
4454 			    macinfo->gldm_addrlen;
4455 			*(ushort_t *)sapp = gld->gld_sap;
4456 		} else {
4457 			dlp->dl_addr_offset = 0;
4458 		}
4459 
4460 		/* copy broadcast addr */
4461 		dlp->dl_brdcst_addr_length = macinfo->gldm_addrlen;
4462 		dlp->dl_brdcst_addr_offset = brdcst_offset;
4463 		mac_copy((caddr_t)macinfo->gldm_broadcast_addr,
4464 		    mp->b_rptr + brdcst_offset, brdcst_length);
4465 	} else {
4466 		/*
4467 		 * No PPA is attached.
4468 		 * The best we can do is use the values provided
4469 		 * by the first mac that called gld_register.
4470 		 */
4471 		dlp->dl_min_sdu = glddev->gld_minsdu;
4472 		dlp->dl_max_sdu = glddev->gld_maxsdu;
4473 		dlp->dl_mac_type = glddev->gld_type;
4474 		dlp->dl_addr_length = addr_length + abs(sap_length);
4475 		dlp->dl_sap_length = sap_length;
4476 		dlp->dl_addr_offset = 0;
4477 		dlp->dl_brdcst_addr_offset = brdcst_offset;
4478 		dlp->dl_brdcst_addr_length = brdcst_length;
4479 		mac_copy((caddr_t)glddev->gld_broadcast,
4480 		    mp->b_rptr + brdcst_offset, brdcst_length);
4481 	}
4482 	qreply(q, mp);
4483 	return (GLDE_OK);
4484 }
4485 
4486 /*
4487  * gld_unitdata (q, mp)
4488  * send a datagram.  Destination address/lsap is in M_PROTO
4489  * message (first mblock), data is in remainder of message.
4490  *
4491  */
4492 static int
4493 gld_unitdata(queue_t *q, mblk_t *mp)
4494 {
4495 	gld_t *gld = (gld_t *)q->q_ptr;
4496 	dl_unitdata_req_t *dlp = (dl_unitdata_req_t *)mp->b_rptr;
4497 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4498 	size_t	msglen;
4499 	mblk_t	*nmp;
4500 	gld_interface_t *ifp;
4501 	uint32_t start;
4502 	uint32_t stuff;
4503 	uint32_t end;
4504 	uint32_t value;
4505 	uint32_t flags;
4506 	uint32_t upri;
4507 
4508 #ifdef GLD_DEBUG
4509 	if (gld_debug & GLDTRACE)
4510 		cmn_err(CE_NOTE, "gld_unitdata(%p %p)", (void *)q, (void *)mp);
4511 #endif
4512 
4513 	if (gld->gld_state != DL_IDLE) {
4514 #ifdef GLD_DEBUG
4515 		if (gld_debug & GLDERRS)
4516 			cmn_err(CE_NOTE, "gld_unitdata: wrong state (%d)",
4517 			    gld->gld_state);
4518 #endif
4519 		dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset,
4520 		    dlp->dl_dest_addr_length, DL_OUTSTATE, 0);
4521 		return (GLDE_OK);
4522 	}
4523 	ASSERT(macinfo != NULL);
4524 
4525 	if (!MBLKIN(mp, dlp->dl_dest_addr_offset, dlp->dl_dest_addr_length) ||
4526 	    dlp->dl_dest_addr_length !=
4527 	    macinfo->gldm_addrlen + abs(macinfo->gldm_saplen)) {
4528 		dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset,
4529 		    dlp->dl_dest_addr_length, DL_BADADDR, 0);
4530 		return (GLDE_OK);
4531 	}
4532 
4533 	upri = dlp->dl_priority.dl_max;
4534 
4535 	msglen = msgdsize(mp);
4536 	if (msglen == 0 || msglen > macinfo->gldm_maxpkt) {
4537 #ifdef GLD_DEBUG
4538 		if (gld_debug & GLDERRS)
4539 			cmn_err(CE_NOTE, "gld_unitdata: bad msglen (%d)",
4540 			    (int)msglen);
4541 #endif
4542 		dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset,
4543 		    dlp->dl_dest_addr_length, DL_BADDATA, 0);
4544 		return (GLDE_OK);
4545 	}
4546 
4547 	ASSERT(mp->b_cont != NULL);	/* because msgdsize(mp) is nonzero */
4548 
4549 	ifp = ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->interfacep;
4550 
4551 	/* grab any checksum information that may be present */
4552 	hcksum_retrieve(mp->b_cont, NULL, NULL, &start, &stuff, &end,
4553 	    &value, &flags);
4554 
4555 	/*
4556 	 * Prepend a valid header for transmission
4557 	 */
4558 	if ((nmp = (*ifp->mkunitdata)(gld, mp)) == NULL) {
4559 #ifdef GLD_DEBUG
4560 		if (gld_debug & GLDERRS)
4561 			cmn_err(CE_NOTE, "gld_unitdata: mkunitdata failed.");
4562 #endif
4563 		dluderrorind(q, mp, mp->b_rptr + dlp->dl_dest_addr_offset,
4564 		    dlp->dl_dest_addr_length, DL_SYSERR, ENOSR);
4565 		return (GLDE_OK);
4566 	}
4567 
4568 	/* apply any checksum information to the first block in the chain */
4569 	(void) hcksum_assoc(nmp, NULL, NULL, start, stuff, end, value,
4570 	    flags, 0);
4571 
4572 	GLD_CLEAR_MBLK_VTAG(nmp);
4573 	if (gld_start(q, nmp, GLD_WSRV, upri) == GLD_NORESOURCES) {
4574 		qenable(q);
4575 		return (GLDE_RETRY);
4576 	}
4577 
4578 	return (GLDE_OK);
4579 }
4580 
4581 /*
4582  * gldattach(q, mp)
4583  * DLPI DL_ATTACH_REQ
4584  * this attaches the stream to a PPA
4585  */
4586 static int
4587 gldattach(queue_t *q, mblk_t *mp)
4588 {
4589 	dl_attach_req_t *at;
4590 	gld_mac_info_t *macinfo;
4591 	gld_t  *gld = (gld_t *)q->q_ptr;
4592 	glddev_t *glddev;
4593 	gld_mac_pvt_t *mac_pvt;
4594 	uint32_t ppa;
4595 	uint32_t vid;
4596 	gld_vlan_t *vlan;
4597 
4598 	at = (dl_attach_req_t *)mp->b_rptr;
4599 
4600 	if (gld->gld_state != DL_UNATTACHED)
4601 		return (DL_OUTSTATE);
4602 
4603 	ASSERT(!gld->gld_mac_info);
4604 
4605 	ppa = at->dl_ppa % GLD_VLAN_SCALE;	/* 0 .. 999	*/
4606 	vid = at->dl_ppa / GLD_VLAN_SCALE;	/* 0 .. 4094	*/
4607 	if (vid > VLAN_VID_MAX)
4608 		return (DL_BADPPA);
4609 
4610 	glddev = gld->gld_device;
4611 	mutex_enter(&glddev->gld_devlock);
4612 	for (macinfo = glddev->gld_mac_next;
4613 	    macinfo != (gld_mac_info_t *)&glddev->gld_mac_next;
4614 	    macinfo = macinfo->gldm_next) {
4615 		int inst;
4616 
4617 		ASSERT(macinfo != NULL);
4618 		if (macinfo->gldm_ppa != ppa)
4619 			continue;
4620 
4621 		if (!(macinfo->gldm_GLD_flags & GLD_MAC_READY))
4622 			continue;	/* this one's not ready yet */
4623 
4624 		/*
4625 		 * VLAN sanity check
4626 		 */
4627 		if (vid != VLAN_VID_NONE && !VLAN_CAPABLE(macinfo)) {
4628 			mutex_exit(&glddev->gld_devlock);
4629 			return (DL_BADPPA);
4630 		}
4631 
4632 		/*
4633 		 * We found the correct PPA, hold the instance
4634 		 */
4635 		inst = ddi_get_instance(macinfo->gldm_devinfo);
4636 		if (inst == -1 || qassociate(q, inst) != 0) {
4637 			mutex_exit(&glddev->gld_devlock);
4638 			return (DL_BADPPA);
4639 		}
4640 
4641 		/* Take the stream off the per-driver-class list */
4642 		gldremque(gld);
4643 
4644 		/*
4645 		 * We must hold the lock to prevent multiple calls
4646 		 * to the reset and start routines.
4647 		 */
4648 		GLDM_LOCK(macinfo, RW_WRITER);
4649 
4650 		gld->gld_mac_info = macinfo;
4651 
4652 		if (macinfo->gldm_send_tagged != NULL)
4653 			gld->gld_send = macinfo->gldm_send_tagged;
4654 		else
4655 			gld->gld_send = macinfo->gldm_send;
4656 
4657 		if ((vlan = gld_get_vlan(macinfo, vid)) == NULL) {
4658 			GLDM_UNLOCK(macinfo);
4659 			gldinsque(gld, glddev->gld_str_prev);
4660 			mutex_exit(&glddev->gld_devlock);
4661 			(void) qassociate(q, -1);
4662 			return (DL_BADPPA);
4663 		}
4664 
4665 		mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4666 		if (!mac_pvt->started) {
4667 			if (gld_start_mac(macinfo) != GLD_SUCCESS) {
4668 				gld_rem_vlan(vlan);
4669 				GLDM_UNLOCK(macinfo);
4670 				gldinsque(gld, glddev->gld_str_prev);
4671 				mutex_exit(&glddev->gld_devlock);
4672 				dlerrorack(q, mp, DL_ATTACH_REQ, DL_SYSERR,
4673 				    EIO);
4674 				(void) qassociate(q, -1);
4675 				return (GLDE_OK);
4676 			}
4677 		}
4678 
4679 		gld->gld_vlan = vlan;
4680 		vlan->gldv_nstreams++;
4681 		gldinsque(gld, vlan->gldv_str_prev);
4682 		gld->gld_state = DL_UNBOUND;
4683 		GLDM_UNLOCK(macinfo);
4684 
4685 #ifdef GLD_DEBUG
4686 		if (gld_debug & GLDPROT) {
4687 			cmn_err(CE_NOTE, "gldattach(%p, %p, PPA = %d)",
4688 			    (void *)q, (void *)mp, macinfo->gldm_ppa);
4689 		}
4690 #endif
4691 		mutex_exit(&glddev->gld_devlock);
4692 		dlokack(q, mp, DL_ATTACH_REQ);
4693 		return (GLDE_OK);
4694 	}
4695 	mutex_exit(&glddev->gld_devlock);
4696 	return (DL_BADPPA);
4697 }
4698 
4699 /*
4700  * gldunattach(q, mp)
4701  * DLPI DL_DETACH_REQ
4702  * detaches the mac layer from the stream
4703  */
4704 int
4705 gldunattach(queue_t *q, mblk_t *mp)
4706 {
4707 	gld_t  *gld = (gld_t *)q->q_ptr;
4708 	glddev_t *glddev = gld->gld_device;
4709 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4710 	int	state = gld->gld_state;
4711 	int	i;
4712 	gld_mac_pvt_t *mac_pvt;
4713 	gld_vlan_t *vlan;
4714 	boolean_t phys_off;
4715 	boolean_t mult_off;
4716 	int op = GLD_MAC_PROMISC_NOOP;
4717 
4718 	if (state != DL_UNBOUND)
4719 		return (DL_OUTSTATE);
4720 
4721 	ASSERT(macinfo != NULL);
4722 	ASSERT(gld->gld_sap == 0);
4723 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4724 
4725 #ifdef GLD_DEBUG
4726 	if (gld_debug & GLDPROT) {
4727 		cmn_err(CE_NOTE, "gldunattach(%p, %p, PPA = %d)",
4728 		    (void *)q, (void *)mp, macinfo->gldm_ppa);
4729 	}
4730 #endif
4731 
4732 	GLDM_LOCK(macinfo, RW_WRITER);
4733 
4734 	if (gld->gld_mcast) {
4735 		for (i = 0; i < gld->gld_multicnt; i++) {
4736 			gld_mcast_t *mcast;
4737 
4738 			if ((mcast = gld->gld_mcast[i]) != NULL) {
4739 				ASSERT(mcast->gldm_refcnt);
4740 				gld_send_disable_multi(macinfo, mcast);
4741 			}
4742 		}
4743 		kmem_free(gld->gld_mcast,
4744 		    sizeof (gld_mcast_t *) * gld->gld_multicnt);
4745 		gld->gld_mcast = NULL;
4746 		gld->gld_multicnt = 0;
4747 	}
4748 
4749 	/* decide if we need to turn off any promiscuity */
4750 	phys_off = (gld->gld_flags & GLD_PROM_PHYS &&
4751 	    --mac_pvt->nprom == 0);
4752 	mult_off = (gld->gld_flags & GLD_PROM_MULT &&
4753 	    --mac_pvt->nprom_multi == 0);
4754 
4755 	if (phys_off) {
4756 		op = (mac_pvt->nprom_multi == 0) ? GLD_MAC_PROMISC_NONE :
4757 		    GLD_MAC_PROMISC_MULTI;
4758 	} else if (mult_off) {
4759 		op = (mac_pvt->nprom == 0) ? GLD_MAC_PROMISC_NONE :
4760 		    GLD_MAC_PROMISC_NOOP;	/* phys overrides multi */
4761 	}
4762 
4763 	if (op != GLD_MAC_PROMISC_NOOP)
4764 		(void) (*macinfo->gldm_set_promiscuous)(macinfo, op);
4765 
4766 	vlan = (gld_vlan_t *)gld->gld_vlan;
4767 	if (gld->gld_flags & GLD_PROM_PHYS)
4768 		vlan->gldv_nprom--;
4769 	if (gld->gld_flags & GLD_PROM_MULT)
4770 		vlan->gldv_nprom--;
4771 	if (gld->gld_flags & GLD_PROM_SAP) {
4772 		vlan->gldv_nprom--;
4773 		vlan->gldv_nvlan_sap--;
4774 	}
4775 
4776 	gld->gld_flags &= ~(GLD_PROM_PHYS | GLD_PROM_SAP | GLD_PROM_MULT);
4777 
4778 	GLDM_UNLOCK(macinfo);
4779 
4780 	if (phys_off)
4781 		gld_notify_ind(macinfo, DL_NOTE_PROMISC_OFF_PHYS, NULL);
4782 
4783 	/*
4784 	 * We need to hold both locks when modifying the mac stream list
4785 	 * to protect findminor as well as everyone else.
4786 	 */
4787 	mutex_enter(&glddev->gld_devlock);
4788 	GLDM_LOCK(macinfo, RW_WRITER);
4789 
4790 	/* disassociate this stream with its vlan and underlying mac */
4791 	gldremque(gld);
4792 
4793 	if (--vlan->gldv_nstreams == 0) {
4794 		gld_rem_vlan(vlan);
4795 		gld->gld_vlan = NULL;
4796 	}
4797 
4798 	gld->gld_mac_info = NULL;
4799 	gld->gld_state = DL_UNATTACHED;
4800 
4801 	/* cleanup mac layer if last vlan */
4802 	if (mac_pvt->nvlan == 0) {
4803 		gld_stop_mac(macinfo);
4804 		macinfo->gldm_GLD_flags &= ~GLD_INTR_WAIT;
4805 	}
4806 
4807 	/* make sure no references to this gld for gld_v0_sched */
4808 	if (mac_pvt->last_sched == gld)
4809 		mac_pvt->last_sched = NULL;
4810 
4811 	GLDM_UNLOCK(macinfo);
4812 
4813 	/* put the stream on the unattached Style 2 list */
4814 	gldinsque(gld, glddev->gld_str_prev);
4815 
4816 	mutex_exit(&glddev->gld_devlock);
4817 
4818 	/* There will be no mp if we were called from close */
4819 	if (mp) {
4820 		dlokack(q, mp, DL_DETACH_REQ);
4821 	}
4822 	if (gld->gld_style == DL_STYLE2)
4823 		(void) qassociate(q, -1);
4824 	return (GLDE_OK);
4825 }
4826 
4827 /*
4828  * gld_enable_multi (q, mp)
4829  * Enables multicast address on the stream.  If the mac layer
4830  * isn't enabled for this address, enable at that level as well.
4831  */
4832 static int
4833 gld_enable_multi(queue_t *q, mblk_t *mp)
4834 {
4835 	gld_t  *gld = (gld_t *)q->q_ptr;
4836 	glddev_t *glddev;
4837 	gld_mac_info_t *macinfo = gld->gld_mac_info;
4838 	unsigned char *maddr;
4839 	dl_enabmulti_req_t *multi;
4840 	gld_mcast_t *mcast;
4841 	int	i, rc;
4842 	gld_mac_pvt_t *mac_pvt;
4843 
4844 #ifdef GLD_DEBUG
4845 	if (gld_debug & GLDPROT) {
4846 		cmn_err(CE_NOTE, "gld_enable_multi(%p, %p)", (void *)q,
4847 		    (void *)mp);
4848 	}
4849 #endif
4850 
4851 	if (gld->gld_state == DL_UNATTACHED)
4852 		return (DL_OUTSTATE);
4853 
4854 	ASSERT(macinfo != NULL);
4855 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
4856 
4857 	if (macinfo->gldm_set_multicast == NULL) {
4858 		return (DL_UNSUPPORTED);
4859 	}
4860 
4861 	multi = (dl_enabmulti_req_t *)mp->b_rptr;
4862 
4863 	if (!MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) ||
4864 	    multi->dl_addr_length != macinfo->gldm_addrlen)
4865 		return (DL_BADADDR);
4866 
4867 	/* request appears to be valid */
4868 
4869 	glddev = mac_pvt->major_dev;
4870 	ASSERT(glddev == gld->gld_device);
4871 
4872 	maddr = mp->b_rptr + multi->dl_addr_offset;
4873 
4874 	/*
4875 	 * The multicast addresses live in a per-device table, along
4876 	 * with a reference count.  Each stream has a table that
4877 	 * points to entries in the device table, with the reference
4878 	 * count reflecting the number of streams pointing at it.  If
4879 	 * this multicast address is already in the per-device table,
4880 	 * all we have to do is point at it.
4881 	 */
4882 	GLDM_LOCK(macinfo, RW_WRITER);
4883 
4884 	/* does this address appear in current table? */
4885 	if (gld->gld_mcast == NULL) {
4886 		/* no mcast addresses -- allocate table */
4887 		gld->gld_mcast = GLD_GETSTRUCT(gld_mcast_t *,
4888 		    glddev->gld_multisize);
4889 		if (gld->gld_mcast == NULL) {
4890 			GLDM_UNLOCK(macinfo);
4891 			dlerrorack(q, mp, DL_ENABMULTI_REQ, DL_SYSERR, ENOSR);
4892 			return (GLDE_OK);
4893 		}
4894 		gld->gld_multicnt = glddev->gld_multisize;
4895 	} else {
4896 		for (i = 0; i < gld->gld_multicnt; i++) {
4897 			if (gld->gld_mcast[i] &&
4898 			    mac_eq(gld->gld_mcast[i]->gldm_addr,
4899 			    maddr, macinfo->gldm_addrlen)) {
4900 				/* this is a match -- just succeed */
4901 				ASSERT(gld->gld_mcast[i]->gldm_refcnt);
4902 				GLDM_UNLOCK(macinfo);
4903 				dlokack(q, mp, DL_ENABMULTI_REQ);
4904 				return (GLDE_OK);
4905 			}
4906 		}
4907 	}
4908 
4909 	/*
4910 	 * it wasn't in the stream so check to see if the mac layer has it
4911 	 */
4912 	mcast = NULL;
4913 	if (mac_pvt->mcast_table == NULL) {
4914 		mac_pvt->mcast_table = GLD_GETSTRUCT(gld_mcast_t,
4915 		    glddev->gld_multisize);
4916 		if (mac_pvt->mcast_table == NULL) {
4917 			GLDM_UNLOCK(macinfo);
4918 			dlerrorack(q, mp, DL_ENABMULTI_REQ, DL_SYSERR, ENOSR);
4919 			return (GLDE_OK);
4920 		}
4921 	} else {
4922 		for (i = 0; i < glddev->gld_multisize; i++) {
4923 			if (mac_pvt->mcast_table[i].gldm_refcnt &&
4924 			    mac_eq(mac_pvt->mcast_table[i].gldm_addr,
4925 			    maddr, macinfo->gldm_addrlen)) {
4926 				mcast = &mac_pvt->mcast_table[i];
4927 				break;
4928 			}
4929 		}
4930 	}
4931 	if (mcast == NULL) {
4932 		/* not in mac layer -- find an empty mac slot to fill in */
4933 		for (i = 0; i < glddev->gld_multisize; i++) {
4934 			if (mac_pvt->mcast_table[i].gldm_refcnt == 0) {
4935 				mcast = &mac_pvt->mcast_table[i];
4936 				mac_copy(maddr, mcast->gldm_addr,
4937 				    macinfo->gldm_addrlen);
4938 				break;
4939 			}
4940 		}
4941 	}
4942 	if (mcast == NULL) {
4943 		/* couldn't get a mac layer slot */
4944 		GLDM_UNLOCK(macinfo);
4945 		return (DL_TOOMANY);
4946 	}
4947 
4948 	/* now we have a mac layer slot in mcast -- get a stream slot */
4949 	for (i = 0; i < gld->gld_multicnt; i++) {
4950 		if (gld->gld_mcast[i] != NULL)
4951 			continue;
4952 		/* found an empty slot */
4953 		if (!mcast->gldm_refcnt) {
4954 			/* set mcast in hardware */
4955 			unsigned char cmaddr[GLD_MAX_ADDRLEN];
4956 
4957 			ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen);
4958 			cmac_copy(maddr, cmaddr,
4959 			    macinfo->gldm_addrlen, macinfo);
4960 
4961 			rc = (*macinfo->gldm_set_multicast)
4962 			    (macinfo, cmaddr, GLD_MULTI_ENABLE);
4963 			if (rc == GLD_NOTSUPPORTED) {
4964 				GLDM_UNLOCK(macinfo);
4965 				return (DL_NOTSUPPORTED);
4966 			} else if (rc == GLD_NORESOURCES) {
4967 				GLDM_UNLOCK(macinfo);
4968 				return (DL_TOOMANY);
4969 			} else if (rc == GLD_BADARG) {
4970 				GLDM_UNLOCK(macinfo);
4971 				return (DL_BADADDR);
4972 			} else if (rc == GLD_RETRY) {
4973 				/*
4974 				 * The putbq and gld_xwait must be
4975 				 * within the lock to prevent races
4976 				 * with gld_sched.
4977 				 */
4978 				(void) putbq(q, mp);
4979 				gld->gld_xwait = B_TRUE;
4980 				GLDM_UNLOCK(macinfo);
4981 				return (GLDE_RETRY);
4982 			} else if (rc != GLD_SUCCESS) {
4983 				GLDM_UNLOCK(macinfo);
4984 				dlerrorack(q, mp, DL_ENABMULTI_REQ,
4985 				    DL_SYSERR, EIO);
4986 				return (GLDE_OK);
4987 			}
4988 		}
4989 		gld->gld_mcast[i] = mcast;
4990 		mcast->gldm_refcnt++;
4991 		GLDM_UNLOCK(macinfo);
4992 		dlokack(q, mp, DL_ENABMULTI_REQ);
4993 		return (GLDE_OK);
4994 	}
4995 
4996 	/* couldn't get a stream slot */
4997 	GLDM_UNLOCK(macinfo);
4998 	return (DL_TOOMANY);
4999 }
5000 
5001 
5002 /*
5003  * gld_disable_multi (q, mp)
5004  * Disable the multicast address on the stream.  If last
5005  * reference for the mac layer, disable there as well.
5006  */
5007 static int
5008 gld_disable_multi(queue_t *q, mblk_t *mp)
5009 {
5010 	gld_t  *gld;
5011 	gld_mac_info_t *macinfo;
5012 	unsigned char *maddr;
5013 	dl_disabmulti_req_t *multi;
5014 	int i;
5015 	gld_mcast_t *mcast;
5016 
5017 #ifdef GLD_DEBUG
5018 	if (gld_debug & GLDPROT) {
5019 		cmn_err(CE_NOTE, "gld_disable_multi(%p, %p)", (void *)q,
5020 		    (void *)mp);
5021 	}
5022 #endif
5023 
5024 	gld = (gld_t *)q->q_ptr;
5025 	if (gld->gld_state == DL_UNATTACHED)
5026 		return (DL_OUTSTATE);
5027 
5028 	macinfo = gld->gld_mac_info;
5029 	ASSERT(macinfo != NULL);
5030 	if (macinfo->gldm_set_multicast == NULL) {
5031 		return (DL_UNSUPPORTED);
5032 	}
5033 
5034 	multi = (dl_disabmulti_req_t *)mp->b_rptr;
5035 
5036 	if (!MBLKIN(mp, multi->dl_addr_offset, multi->dl_addr_length) ||
5037 	    multi->dl_addr_length != macinfo->gldm_addrlen)
5038 		return (DL_BADADDR);
5039 
5040 	maddr = mp->b_rptr + multi->dl_addr_offset;
5041 
5042 	/* request appears to be valid */
5043 	/* does this address appear in current table? */
5044 	GLDM_LOCK(macinfo, RW_WRITER);
5045 	if (gld->gld_mcast != NULL) {
5046 		for (i = 0; i < gld->gld_multicnt; i++)
5047 			if (((mcast = gld->gld_mcast[i]) != NULL) &&
5048 			    mac_eq(mcast->gldm_addr,
5049 			    maddr, macinfo->gldm_addrlen)) {
5050 				ASSERT(mcast->gldm_refcnt);
5051 				gld_send_disable_multi(macinfo, mcast);
5052 				gld->gld_mcast[i] = NULL;
5053 				GLDM_UNLOCK(macinfo);
5054 				dlokack(q, mp, DL_DISABMULTI_REQ);
5055 				return (GLDE_OK);
5056 			}
5057 	}
5058 	GLDM_UNLOCK(macinfo);
5059 	return (DL_NOTENAB); /* not an enabled address */
5060 }
5061 
5062 /*
5063  * gld_send_disable_multi(macinfo, mcast)
5064  * this function is used to disable a multicast address if the reference
5065  * count goes to zero. The disable request will then be forwarded to the
5066  * lower stream.
5067  */
5068 static void
5069 gld_send_disable_multi(gld_mac_info_t *macinfo, gld_mcast_t *mcast)
5070 {
5071 	ASSERT(macinfo != NULL);
5072 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
5073 	ASSERT(mcast != NULL);
5074 	ASSERT(mcast->gldm_refcnt);
5075 
5076 	if (!mcast->gldm_refcnt) {
5077 		return;			/* "cannot happen" */
5078 	}
5079 
5080 	if (--mcast->gldm_refcnt > 0) {
5081 		return;
5082 	}
5083 
5084 	/*
5085 	 * This must be converted from canonical form to device form.
5086 	 * The refcnt is now zero so we can trash the data.
5087 	 */
5088 	if (macinfo->gldm_options & GLDOPT_CANONICAL_ADDR)
5089 		gld_bitreverse(mcast->gldm_addr, macinfo->gldm_addrlen);
5090 
5091 	/* XXX Ought to check for GLD_NORESOURCES or GLD_FAILURE */
5092 	(void) (*macinfo->gldm_set_multicast)
5093 	    (macinfo, mcast->gldm_addr, GLD_MULTI_DISABLE);
5094 }
5095 
5096 /*
5097  * gld_promisc (q, mp, req, on)
5098  *	enable or disable the use of promiscuous mode with the hardware
5099  */
5100 static int
5101 gld_promisc(queue_t *q, mblk_t *mp, t_uscalar_t req, boolean_t on)
5102 {
5103 	gld_t *gld;
5104 	gld_mac_info_t *macinfo;
5105 	gld_mac_pvt_t *mac_pvt;
5106 	gld_vlan_t *vlan;
5107 	union DL_primitives *prim;
5108 	int macrc = GLD_SUCCESS;
5109 	int dlerr = GLDE_OK;
5110 	int op = GLD_MAC_PROMISC_NOOP;
5111 
5112 #ifdef GLD_DEBUG
5113 	if (gld_debug & GLDTRACE)
5114 		cmn_err(CE_NOTE, "gld_promisc(%p, %p, %d, %d)",
5115 		    (void *)q, (void *)mp, req, on);
5116 #endif
5117 
5118 	ASSERT(mp != NULL);
5119 	prim = (union DL_primitives *)mp->b_rptr;
5120 
5121 	/* XXX I think spec allows promisc in unattached state */
5122 	gld = (gld_t *)q->q_ptr;
5123 	if (gld->gld_state == DL_UNATTACHED)
5124 		return (DL_OUTSTATE);
5125 
5126 	macinfo = gld->gld_mac_info;
5127 	ASSERT(macinfo != NULL);
5128 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5129 
5130 	vlan = (gld_vlan_t *)gld->gld_vlan;
5131 	ASSERT(vlan != NULL);
5132 
5133 	GLDM_LOCK(macinfo, RW_WRITER);
5134 
5135 	/*
5136 	 * Work out what request (if any) has to be made to the MAC layer
5137 	 */
5138 	if (on) {
5139 		switch (prim->promiscon_req.dl_level) {
5140 		default:
5141 			dlerr = DL_UNSUPPORTED;	/* this is an error */
5142 			break;
5143 
5144 		case DL_PROMISC_PHYS:
5145 			if (mac_pvt->nprom == 0)
5146 				op = GLD_MAC_PROMISC_PHYS;
5147 			break;
5148 
5149 		case DL_PROMISC_MULTI:
5150 			if (mac_pvt->nprom_multi == 0)
5151 				if (mac_pvt->nprom == 0)
5152 					op = GLD_MAC_PROMISC_MULTI;
5153 			break;
5154 
5155 		case DL_PROMISC_SAP:
5156 			/* We can do this without reference to the MAC */
5157 			break;
5158 		}
5159 	} else {
5160 		switch (prim->promiscoff_req.dl_level) {
5161 		default:
5162 			dlerr = DL_UNSUPPORTED;	/* this is an error */
5163 			break;
5164 
5165 		case DL_PROMISC_PHYS:
5166 			if (!(gld->gld_flags & GLD_PROM_PHYS))
5167 				dlerr = DL_NOTENAB;
5168 			else if (mac_pvt->nprom == 1)
5169 				if (mac_pvt->nprom_multi)
5170 					op = GLD_MAC_PROMISC_MULTI;
5171 				else
5172 					op = GLD_MAC_PROMISC_NONE;
5173 			break;
5174 
5175 		case DL_PROMISC_MULTI:
5176 			if (!(gld->gld_flags & GLD_PROM_MULT))
5177 				dlerr = DL_NOTENAB;
5178 			else if (mac_pvt->nprom_multi == 1)
5179 				if (mac_pvt->nprom == 0)
5180 					op = GLD_MAC_PROMISC_NONE;
5181 			break;
5182 
5183 		case DL_PROMISC_SAP:
5184 			if (!(gld->gld_flags & GLD_PROM_SAP))
5185 				dlerr = DL_NOTENAB;
5186 
5187 			/* We can do this without reference to the MAC */
5188 			break;
5189 		}
5190 	}
5191 
5192 	/*
5193 	 * The request was invalid in some way so no need to continue.
5194 	 */
5195 	if (dlerr != GLDE_OK) {
5196 		GLDM_UNLOCK(macinfo);
5197 		return (dlerr);
5198 	}
5199 
5200 	/*
5201 	 * Issue the request to the MAC layer, if required
5202 	 */
5203 	if (op != GLD_MAC_PROMISC_NOOP) {
5204 		macrc = (*macinfo->gldm_set_promiscuous)(macinfo, op);
5205 	}
5206 
5207 	/*
5208 	 * On success, update the appropriate flags & refcounts
5209 	 */
5210 	if (macrc == GLD_SUCCESS) {
5211 		if (on) {
5212 			switch (prim->promiscon_req.dl_level) {
5213 			case DL_PROMISC_PHYS:
5214 				mac_pvt->nprom++;
5215 				vlan->gldv_nprom++;
5216 				gld->gld_flags |= GLD_PROM_PHYS;
5217 				break;
5218 
5219 			case DL_PROMISC_MULTI:
5220 				mac_pvt->nprom_multi++;
5221 				vlan->gldv_nprom++;
5222 				gld->gld_flags |= GLD_PROM_MULT;
5223 				break;
5224 
5225 			case DL_PROMISC_SAP:
5226 				gld->gld_flags |= GLD_PROM_SAP;
5227 				vlan->gldv_nprom++;
5228 				vlan->gldv_nvlan_sap++;
5229 				break;
5230 
5231 			default:
5232 				break;
5233 			}
5234 		} else {
5235 			switch (prim->promiscoff_req.dl_level) {
5236 			case DL_PROMISC_PHYS:
5237 				mac_pvt->nprom--;
5238 				vlan->gldv_nprom--;
5239 				gld->gld_flags &= ~GLD_PROM_PHYS;
5240 				break;
5241 
5242 			case DL_PROMISC_MULTI:
5243 				mac_pvt->nprom_multi--;
5244 				vlan->gldv_nprom--;
5245 				gld->gld_flags &= ~GLD_PROM_MULT;
5246 				break;
5247 
5248 			case DL_PROMISC_SAP:
5249 				gld->gld_flags &= ~GLD_PROM_SAP;
5250 				vlan->gldv_nvlan_sap--;
5251 				vlan->gldv_nprom--;
5252 				break;
5253 
5254 			default:
5255 				break;
5256 			}
5257 		}
5258 	} else if (macrc == GLD_RETRY) {
5259 		/*
5260 		 * The putbq and gld_xwait must be within the lock to
5261 		 * prevent races with gld_sched.
5262 		 */
5263 		(void) putbq(q, mp);
5264 		gld->gld_xwait = B_TRUE;
5265 	}
5266 
5267 	GLDM_UNLOCK(macinfo);
5268 
5269 	/*
5270 	 * Finally, decide how to reply.
5271 	 *
5272 	 * If <macrc> is not GLD_SUCCESS, the request was put to the MAC
5273 	 * layer but failed.  In such cases, we can return a DL_* error
5274 	 * code and let the caller send an error-ack reply upstream, or
5275 	 * we can send a reply here and then return GLDE_OK so that the
5276 	 * caller doesn't also respond.
5277 	 *
5278 	 * If physical-promiscuous mode was (successfully) switched on or
5279 	 * off, send a notification (DL_NOTIFY_IND) to anyone interested.
5280 	 */
5281 	switch (macrc) {
5282 	case GLD_NOTSUPPORTED:
5283 		return (DL_NOTSUPPORTED);
5284 
5285 	case GLD_NORESOURCES:
5286 		dlerrorack(q, mp, req, DL_SYSERR, ENOSR);
5287 		return (GLDE_OK);
5288 
5289 	case GLD_RETRY:
5290 		return (GLDE_RETRY);
5291 
5292 	default:
5293 		dlerrorack(q, mp, req, DL_SYSERR, EIO);
5294 		return (GLDE_OK);
5295 
5296 	case GLD_SUCCESS:
5297 		dlokack(q, mp, req);
5298 		break;
5299 	}
5300 
5301 	switch (op) {
5302 	case GLD_MAC_PROMISC_NOOP:
5303 		break;
5304 
5305 	case GLD_MAC_PROMISC_PHYS:
5306 		gld_notify_ind(macinfo, DL_NOTE_PROMISC_ON_PHYS, NULL);
5307 		break;
5308 
5309 	default:
5310 		gld_notify_ind(macinfo, DL_NOTE_PROMISC_OFF_PHYS, NULL);
5311 		break;
5312 	}
5313 
5314 	return (GLDE_OK);
5315 }
5316 
5317 /*
5318  * gld_physaddr()
5319  *	get the current or factory physical address value
5320  */
5321 static int
5322 gld_physaddr(queue_t *q, mblk_t *mp)
5323 {
5324 	gld_t *gld = (gld_t *)q->q_ptr;
5325 	gld_mac_info_t *macinfo;
5326 	union DL_primitives *prim = (union DL_primitives *)mp->b_rptr;
5327 	unsigned char addr[GLD_MAX_ADDRLEN];
5328 
5329 	if (gld->gld_state == DL_UNATTACHED)
5330 		return (DL_OUTSTATE);
5331 
5332 	macinfo = (gld_mac_info_t *)gld->gld_mac_info;
5333 	ASSERT(macinfo != NULL);
5334 	ASSERT(macinfo->gldm_addrlen <= GLD_MAX_ADDRLEN);
5335 
5336 	switch (prim->physaddr_req.dl_addr_type) {
5337 	case DL_FACT_PHYS_ADDR:
5338 		mac_copy((caddr_t)macinfo->gldm_vendor_addr,
5339 		    (caddr_t)addr, macinfo->gldm_addrlen);
5340 		break;
5341 	case DL_CURR_PHYS_ADDR:
5342 		/* make a copy so we don't hold the lock across qreply */
5343 		GLDM_LOCK(macinfo, RW_WRITER);
5344 		mac_copy((caddr_t)
5345 		    ((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)->curr_macaddr,
5346 		    (caddr_t)addr, macinfo->gldm_addrlen);
5347 		GLDM_UNLOCK(macinfo);
5348 		break;
5349 	default:
5350 		return (DL_BADPRIM);
5351 	}
5352 	dlphysaddrack(q, mp, (caddr_t)addr, macinfo->gldm_addrlen);
5353 	return (GLDE_OK);
5354 }
5355 
5356 /*
5357  * gld_setaddr()
5358  *	change the hardware's physical address to a user specified value
5359  */
5360 static int
5361 gld_setaddr(queue_t *q, mblk_t *mp)
5362 {
5363 	gld_t *gld = (gld_t *)q->q_ptr;
5364 	gld_mac_info_t *macinfo;
5365 	gld_mac_pvt_t *mac_pvt;
5366 	union DL_primitives *prim = (union DL_primitives *)mp->b_rptr;
5367 	unsigned char *addr;
5368 	unsigned char cmaddr[GLD_MAX_ADDRLEN];
5369 	int rc;
5370 	gld_vlan_t *vlan;
5371 
5372 	if (gld->gld_state == DL_UNATTACHED)
5373 		return (DL_OUTSTATE);
5374 
5375 	vlan = (gld_vlan_t *)gld->gld_vlan;
5376 	ASSERT(vlan != NULL);
5377 
5378 	if (vlan->gldv_id != VLAN_VID_NONE)
5379 		return (DL_NOTSUPPORTED);
5380 
5381 	macinfo = (gld_mac_info_t *)gld->gld_mac_info;
5382 	ASSERT(macinfo != NULL);
5383 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5384 
5385 	if (!MBLKIN(mp, prim->set_physaddr_req.dl_addr_offset,
5386 	    prim->set_physaddr_req.dl_addr_length) ||
5387 	    prim->set_physaddr_req.dl_addr_length != macinfo->gldm_addrlen)
5388 		return (DL_BADADDR);
5389 
5390 	GLDM_LOCK(macinfo, RW_WRITER);
5391 
5392 	/* now do the set at the hardware level */
5393 	addr = mp->b_rptr + prim->set_physaddr_req.dl_addr_offset;
5394 	ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen);
5395 	cmac_copy(addr, cmaddr, macinfo->gldm_addrlen, macinfo);
5396 
5397 	rc = (*macinfo->gldm_set_mac_addr)(macinfo, cmaddr);
5398 	if (rc == GLD_SUCCESS)
5399 		mac_copy(addr, mac_pvt->curr_macaddr,
5400 		    macinfo->gldm_addrlen);
5401 
5402 	GLDM_UNLOCK(macinfo);
5403 
5404 	switch (rc) {
5405 	case GLD_SUCCESS:
5406 		break;
5407 	case GLD_NOTSUPPORTED:
5408 		return (DL_NOTSUPPORTED);
5409 	case GLD_BADARG:
5410 		return (DL_BADADDR);
5411 	case GLD_NORESOURCES:
5412 		dlerrorack(q, mp, DL_SET_PHYS_ADDR_REQ, DL_SYSERR, ENOSR);
5413 		return (GLDE_OK);
5414 	default:
5415 		dlerrorack(q, mp, DL_SET_PHYS_ADDR_REQ, DL_SYSERR, EIO);
5416 		return (GLDE_OK);
5417 	}
5418 
5419 	gld_notify_ind(macinfo, DL_NOTE_PHYS_ADDR, NULL);
5420 
5421 	dlokack(q, mp, DL_SET_PHYS_ADDR_REQ);
5422 	return (GLDE_OK);
5423 }
5424 
5425 int
5426 gld_get_statistics(queue_t *q, mblk_t *mp)
5427 {
5428 	dl_get_statistics_ack_t *dlsp;
5429 	gld_t  *gld = (gld_t *)q->q_ptr;
5430 	gld_mac_info_t *macinfo = gld->gld_mac_info;
5431 	gld_mac_pvt_t *mac_pvt;
5432 
5433 	if (gld->gld_state == DL_UNATTACHED)
5434 		return (DL_OUTSTATE);
5435 
5436 	ASSERT(macinfo != NULL);
5437 
5438 	mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5439 	(void) gld_update_kstat(mac_pvt->kstatp, KSTAT_READ);
5440 
5441 	mp = mexchange(q, mp, DL_GET_STATISTICS_ACK_SIZE +
5442 	    sizeof (struct gldkstats), M_PCPROTO, DL_GET_STATISTICS_ACK);
5443 
5444 	if (mp == NULL)
5445 		return (GLDE_OK);	/* mexchange already sent merror */
5446 
5447 	dlsp = (dl_get_statistics_ack_t *)mp->b_rptr;
5448 	dlsp->dl_primitive = DL_GET_STATISTICS_ACK;
5449 	dlsp->dl_stat_length = sizeof (struct gldkstats);
5450 	dlsp->dl_stat_offset = DL_GET_STATISTICS_ACK_SIZE;
5451 
5452 	GLDM_LOCK(macinfo, RW_WRITER);
5453 	bcopy(mac_pvt->kstatp->ks_data,
5454 	    (mp->b_rptr + DL_GET_STATISTICS_ACK_SIZE),
5455 	    sizeof (struct gldkstats));
5456 	GLDM_UNLOCK(macinfo);
5457 
5458 	qreply(q, mp);
5459 	return (GLDE_OK);
5460 }
5461 
5462 /* =================================================== */
5463 /* misc utilities, some requiring various mutexes held */
5464 /* =================================================== */
5465 
5466 /*
5467  * Initialize and start the driver.
5468  */
5469 static int
5470 gld_start_mac(gld_mac_info_t *macinfo)
5471 {
5472 	int	rc;
5473 	unsigned char cmaddr[GLD_MAX_ADDRLEN];
5474 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5475 
5476 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
5477 	ASSERT(!mac_pvt->started);
5478 
5479 	rc = (*macinfo->gldm_reset)(macinfo);
5480 	if (rc != GLD_SUCCESS)
5481 		return (GLD_FAILURE);
5482 
5483 	/* set the addr after we reset the device */
5484 	ASSERT(sizeof (cmaddr) >= macinfo->gldm_addrlen);
5485 	cmac_copy(((gld_mac_pvt_t *)macinfo->gldm_mac_pvt)
5486 	    ->curr_macaddr, cmaddr, macinfo->gldm_addrlen, macinfo);
5487 
5488 	rc = (*macinfo->gldm_set_mac_addr)(macinfo, cmaddr);
5489 	ASSERT(rc != GLD_BADARG);  /* this address was good before */
5490 	if (rc != GLD_SUCCESS && rc != GLD_NOTSUPPORTED)
5491 		return (GLD_FAILURE);
5492 
5493 	rc = (*macinfo->gldm_start)(macinfo);
5494 	if (rc != GLD_SUCCESS)
5495 		return (GLD_FAILURE);
5496 
5497 	mac_pvt->started = B_TRUE;
5498 	return (GLD_SUCCESS);
5499 }
5500 
5501 /*
5502  * Stop the driver.
5503  */
5504 static void
5505 gld_stop_mac(gld_mac_info_t *macinfo)
5506 {
5507 	gld_mac_pvt_t *mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5508 
5509 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
5510 	ASSERT(mac_pvt->started);
5511 
5512 	(void) (*macinfo->gldm_stop)(macinfo);
5513 
5514 	mac_pvt->started = B_FALSE;
5515 }
5516 
5517 
5518 /*
5519  * gld_set_ipq will set a pointer to the queue which is bound to the
5520  * IP sap if:
5521  * o the device type is ethernet or IPoIB.
5522  * o there is no stream in SAP promiscuous mode.
5523  * o there is exactly one stream bound to the IP sap.
5524  * o the stream is in "fastpath" mode.
5525  */
5526 static void
5527 gld_set_ipq(gld_t *gld)
5528 {
5529 	gld_vlan_t	*vlan;
5530 	gld_mac_info_t	*macinfo = gld->gld_mac_info;
5531 	gld_t		*ip_gld = NULL;
5532 	uint_t		ipq_candidates = 0;
5533 	gld_t		*ipv6_gld = NULL;
5534 	uint_t		ipv6q_candidates = 0;
5535 
5536 	ASSERT(GLDM_LOCK_HELD_WRITE(macinfo));
5537 
5538 	/* The ipq code in gld_recv() is intimate with ethernet/IPoIB */
5539 	if (((macinfo->gldm_type != DL_ETHER) &&
5540 	    (macinfo->gldm_type != DL_IB)) ||
5541 	    (gld_global_options & GLD_OPT_NO_IPQ))
5542 		return;
5543 
5544 	vlan = (gld_vlan_t *)gld->gld_vlan;
5545 	ASSERT(vlan != NULL);
5546 
5547 	/* clear down any previously defined ipqs */
5548 	vlan->gldv_ipq = NULL;
5549 	vlan->gldv_ipv6q = NULL;
5550 
5551 	/* Try to find a single stream eligible to receive IP packets */
5552 	for (gld = vlan->gldv_str_next;
5553 	    gld != (gld_t *)&vlan->gldv_str_next; gld = gld->gld_next) {
5554 		if (gld->gld_state != DL_IDLE)
5555 			continue;	/* not eligible to receive */
5556 		if (gld->gld_flags & GLD_STR_CLOSING)
5557 			continue;	/* not eligible to receive */
5558 
5559 		if (gld->gld_sap == ETHERTYPE_IP) {
5560 			ip_gld = gld;
5561 			ipq_candidates++;
5562 		}
5563 
5564 		if (gld->gld_sap == ETHERTYPE_IPV6) {
5565 			ipv6_gld = gld;
5566 			ipv6q_candidates++;
5567 		}
5568 	}
5569 
5570 	if (ipq_candidates == 1) {
5571 		ASSERT(ip_gld != NULL);
5572 
5573 		if (ip_gld->gld_flags & GLD_FAST)	/* eligible for ipq */
5574 			vlan->gldv_ipq = ip_gld->gld_qptr;
5575 	}
5576 
5577 	if (ipv6q_candidates == 1) {
5578 		ASSERT(ipv6_gld != NULL);
5579 
5580 		if (ipv6_gld->gld_flags & GLD_FAST)	/* eligible for ipq */
5581 			vlan->gldv_ipv6q = ipv6_gld->gld_qptr;
5582 	}
5583 }
5584 
5585 /*
5586  * gld_flushqueue (q)
5587  *	used by DLPI primitives that require flushing the queues.
5588  *	essentially, this is DL_UNBIND_REQ.
5589  */
5590 static void
5591 gld_flushqueue(queue_t *q)
5592 {
5593 	/* flush all data in both queues */
5594 	/* XXX Should these be FLUSHALL? */
5595 	flushq(q, FLUSHDATA);
5596 	flushq(WR(q), FLUSHDATA);
5597 	/* flush all the queues upstream */
5598 	(void) putctl1(q, M_FLUSH, FLUSHRW);
5599 }
5600 
5601 /*
5602  * gld_devlookup (major)
5603  * search the device table for the device with specified
5604  * major number and return a pointer to it if it exists
5605  */
5606 static glddev_t *
5607 gld_devlookup(int major)
5608 {
5609 	struct glddevice *dev;
5610 
5611 	ASSERT(mutex_owned(&gld_device_list.gld_devlock));
5612 
5613 	for (dev = gld_device_list.gld_next;
5614 	    dev != &gld_device_list;
5615 	    dev = dev->gld_next) {
5616 		ASSERT(dev);
5617 		if (dev->gld_major == major)
5618 			return (dev);
5619 	}
5620 	return (NULL);
5621 }
5622 
5623 /*
5624  * gld_findminor(device)
5625  * Returns a minor number currently unused by any stream in the current
5626  * device class (major) list.
5627  */
5628 static int
5629 gld_findminor(glddev_t *device)
5630 {
5631 	gld_t		*next;
5632 	gld_mac_info_t	*nextmac;
5633 	gld_vlan_t	*nextvlan;
5634 	int		minor;
5635 	int		i;
5636 
5637 	ASSERT(mutex_owned(&device->gld_devlock));
5638 
5639 	/* The fast way */
5640 	if (device->gld_nextminor >= GLD_MIN_CLONE_MINOR &&
5641 	    device->gld_nextminor <= GLD_MAX_CLONE_MINOR)
5642 		return (device->gld_nextminor++);
5643 
5644 	/* The steady way */
5645 	for (minor = GLD_MIN_CLONE_MINOR; minor <= GLD_MAX_CLONE_MINOR;
5646 	    minor++) {
5647 		/* Search all unattached streams */
5648 		for (next = device->gld_str_next;
5649 		    next != (gld_t *)&device->gld_str_next;
5650 		    next = next->gld_next) {
5651 			if (minor == next->gld_minor)
5652 				goto nextminor;
5653 		}
5654 		/* Search all attached streams; we don't need maclock because */
5655 		/* mac stream list is protected by devlock as well as maclock */
5656 		for (nextmac = device->gld_mac_next;
5657 		    nextmac != (gld_mac_info_t *)&device->gld_mac_next;
5658 		    nextmac = nextmac->gldm_next) {
5659 			gld_mac_pvt_t *pvt =
5660 			    (gld_mac_pvt_t *)nextmac->gldm_mac_pvt;
5661 
5662 			if (!(nextmac->gldm_GLD_flags & GLD_MAC_READY))
5663 				continue;	/* this one's not ready yet */
5664 
5665 			for (i = 0; i < VLAN_HASHSZ; i++) {
5666 				for (nextvlan = pvt->vlan_hash[i];
5667 				    nextvlan != NULL;
5668 				    nextvlan = nextvlan->gldv_next) {
5669 					for (next = nextvlan->gldv_str_next;
5670 					    next !=
5671 					    (gld_t *)&nextvlan->gldv_str_next;
5672 					    next = next->gld_next) {
5673 						if (minor == next->gld_minor)
5674 							goto nextminor;
5675 					}
5676 				}
5677 			}
5678 		}
5679 
5680 		return (minor);
5681 nextminor:
5682 		/* don't need to do anything */
5683 		;
5684 	}
5685 	cmn_err(CE_WARN, "GLD ran out of minor numbers for %s",
5686 	    device->gld_name);
5687 	return (0);
5688 }
5689 
5690 /*
5691  * version of insque/remque for use by this driver
5692  */
5693 struct qelem {
5694 	struct qelem *q_forw;
5695 	struct qelem *q_back;
5696 	/* rest of structure */
5697 };
5698 
5699 static void
5700 gldinsque(void *elem, void *pred)
5701 {
5702 	struct qelem *pelem = elem;
5703 	struct qelem *ppred = pred;
5704 	struct qelem *pnext = ppred->q_forw;
5705 
5706 	pelem->q_forw = pnext;
5707 	pelem->q_back = ppred;
5708 	ppred->q_forw = pelem;
5709 	pnext->q_back = pelem;
5710 }
5711 
5712 static void
5713 gldremque(void *arg)
5714 {
5715 	struct qelem *pelem = arg;
5716 	struct qelem *elem = arg;
5717 
5718 	pelem->q_forw->q_back = pelem->q_back;
5719 	pelem->q_back->q_forw = pelem->q_forw;
5720 	elem->q_back = elem->q_forw = NULL;
5721 }
5722 
5723 static gld_vlan_t *
5724 gld_add_vlan(gld_mac_info_t *macinfo, uint32_t vid)
5725 {
5726 	gld_mac_pvt_t	*mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5727 	gld_vlan_t	**pp;
5728 	gld_vlan_t	*p;
5729 
5730 	pp = &(mac_pvt->vlan_hash[vid % VLAN_HASHSZ]);
5731 	while ((p = *pp) != NULL) {
5732 		ASSERT(p->gldv_id != vid);
5733 		pp = &(p->gldv_next);
5734 	}
5735 
5736 	if ((p = kmem_zalloc(sizeof (gld_vlan_t), KM_NOSLEEP)) == NULL)
5737 		return (NULL);
5738 
5739 	p->gldv_mac = macinfo;
5740 	p->gldv_id = vid;
5741 
5742 	if (vid == VLAN_VID_NONE) {
5743 		p->gldv_ptag = VLAN_VTAG_NONE;
5744 		p->gldv_stats = mac_pvt->statistics;
5745 		p->gldv_kstatp = NULL;
5746 	} else {
5747 		p->gldv_ptag = GLD_MK_PTAG(VLAN_CFI_ETHER, vid);
5748 		p->gldv_stats = kmem_zalloc(sizeof (struct gld_stats),
5749 		    KM_SLEEP);
5750 
5751 		if (gld_init_vlan_stats(p) != GLD_SUCCESS) {
5752 			kmem_free(p->gldv_stats, sizeof (struct gld_stats));
5753 			kmem_free(p, sizeof (gld_vlan_t));
5754 			return (NULL);
5755 		}
5756 	}
5757 
5758 	p->gldv_str_next = p->gldv_str_prev = (gld_t *)&p->gldv_str_next;
5759 	mac_pvt->nvlan++;
5760 	*pp = p;
5761 
5762 	return (p);
5763 }
5764 
5765 static void
5766 gld_rem_vlan(gld_vlan_t *vlan)
5767 {
5768 	gld_mac_info_t	*macinfo = vlan->gldv_mac;
5769 	gld_mac_pvt_t	*mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5770 	gld_vlan_t	**pp;
5771 	gld_vlan_t	*p;
5772 
5773 	pp = &(mac_pvt->vlan_hash[vlan->gldv_id % VLAN_HASHSZ]);
5774 	while ((p = *pp) != NULL) {
5775 		if (p->gldv_id == vlan->gldv_id)
5776 			break;
5777 		pp = &(p->gldv_next);
5778 	}
5779 	ASSERT(p != NULL);
5780 
5781 	*pp = p->gldv_next;
5782 	mac_pvt->nvlan--;
5783 	if (p->gldv_id != VLAN_VID_NONE) {
5784 		ASSERT(p->gldv_kstatp != NULL);
5785 		kstat_delete(p->gldv_kstatp);
5786 		kmem_free(p->gldv_stats, sizeof (struct gld_stats));
5787 	}
5788 	kmem_free(p, sizeof (gld_vlan_t));
5789 }
5790 
5791 gld_vlan_t *
5792 gld_find_vlan(gld_mac_info_t *macinfo, uint32_t vid)
5793 {
5794 	gld_mac_pvt_t	*mac_pvt = (gld_mac_pvt_t *)macinfo->gldm_mac_pvt;
5795 	gld_vlan_t	*p;
5796 
5797 	p = mac_pvt->vlan_hash[vid % VLAN_HASHSZ];
5798 	while (p != NULL) {
5799 		if (p->gldv_id == vid)
5800 			return (p);
5801 		p = p->gldv_next;
5802 	}
5803 	return (NULL);
5804 }
5805 
5806 gld_vlan_t *
5807 gld_get_vlan(gld_mac_info_t *macinfo, uint32_t vid)
5808 {
5809 	gld_vlan_t	*vlan;
5810 
5811 	if ((vlan = gld_find_vlan(macinfo, vid)) == NULL)
5812 		vlan = gld_add_vlan(macinfo, vid);
5813 
5814 	return (vlan);
5815 }
5816 
5817 /*
5818  * gld_bitrevcopy()
5819  * This is essentially bcopy, with the ability to bit reverse the
5820  * the source bytes. The MAC addresses bytes as transmitted by FDDI
5821  * interfaces are bit reversed.
5822  */
5823 void
5824 gld_bitrevcopy(caddr_t src, caddr_t target, size_t n)
5825 {
5826 	while (n--)
5827 		*target++ = bit_rev[(uchar_t)*src++];
5828 }
5829 
5830 /*
5831  * gld_bitreverse()
5832  * Convert the bit order by swaping all the bits, using a
5833  * lookup table.
5834  */
5835 void
5836 gld_bitreverse(uchar_t *rptr, size_t n)
5837 {
5838 	while (n--) {
5839 		*rptr = bit_rev[*rptr];
5840 		rptr++;
5841 	}
5842 }
5843 
5844 char *
5845 gld_macaddr_sprintf(char *etherbuf, unsigned char *ap, int len)
5846 {
5847 	int i;
5848 	char *cp = etherbuf;
5849 	static char digits[] = "0123456789abcdef";
5850 
5851 	for (i = 0; i < len; i++) {
5852 		*cp++ = digits[*ap >> 4];
5853 		*cp++ = digits[*ap++ & 0xf];
5854 		*cp++ = ':';
5855 	}
5856 	*--cp = 0;
5857 	return (etherbuf);
5858 }
5859 
5860 #ifdef GLD_DEBUG
5861 static void
5862 gld_check_assertions()
5863 {
5864 	glddev_t	*dev;
5865 	gld_mac_info_t	*mac;
5866 	gld_t		*str;
5867 	gld_vlan_t	*vlan;
5868 	int		i;
5869 
5870 	mutex_enter(&gld_device_list.gld_devlock);
5871 
5872 	for (dev = gld_device_list.gld_next;
5873 	    dev != (glddev_t *)&gld_device_list.gld_next;
5874 	    dev = dev->gld_next) {
5875 		mutex_enter(&dev->gld_devlock);
5876 		ASSERT(dev->gld_broadcast != NULL);
5877 		for (str = dev->gld_str_next;
5878 		    str != (gld_t *)&dev->gld_str_next;
5879 		    str = str->gld_next) {
5880 			ASSERT(str->gld_device == dev);
5881 			ASSERT(str->gld_mac_info == NULL);
5882 			ASSERT(str->gld_qptr != NULL);
5883 			ASSERT(str->gld_minor >= GLD_MIN_CLONE_MINOR);
5884 			ASSERT(str->gld_multicnt == 0);
5885 			ASSERT(str->gld_mcast == NULL);
5886 			ASSERT(!(str->gld_flags &
5887 			    (GLD_PROM_PHYS|GLD_PROM_MULT|GLD_PROM_SAP)));
5888 			ASSERT(str->gld_sap == 0);
5889 			ASSERT(str->gld_state == DL_UNATTACHED);
5890 		}
5891 		for (mac = dev->gld_mac_next;
5892 		    mac != (gld_mac_info_t *)&dev->gld_mac_next;
5893 		    mac = mac->gldm_next) {
5894 			int nvlan = 0;
5895 			gld_mac_pvt_t *pvt = (gld_mac_pvt_t *)mac->gldm_mac_pvt;
5896 
5897 			if (!(mac->gldm_GLD_flags & GLD_MAC_READY))
5898 				continue;	/* this one's not ready yet */
5899 
5900 			GLDM_LOCK(mac, RW_WRITER);
5901 			ASSERT(mac->gldm_devinfo != NULL);
5902 			ASSERT(mac->gldm_mac_pvt != NULL);
5903 			ASSERT(pvt->interfacep != NULL);
5904 			ASSERT(pvt->kstatp != NULL);
5905 			ASSERT(pvt->statistics != NULL);
5906 			ASSERT(pvt->major_dev == dev);
5907 
5908 			for (i = 0; i < VLAN_HASHSZ; i++) {
5909 				for (vlan = pvt->vlan_hash[i];
5910 				    vlan != NULL; vlan = vlan->gldv_next) {
5911 					int nstr = 0;
5912 
5913 					ASSERT(vlan->gldv_mac == mac);
5914 
5915 					for (str = vlan->gldv_str_next;
5916 					    str !=
5917 					    (gld_t *)&vlan->gldv_str_next;
5918 					    str = str->gld_next) {
5919 						ASSERT(str->gld_device == dev);
5920 						ASSERT(str->gld_mac_info ==
5921 						    mac);
5922 						ASSERT(str->gld_qptr != NULL);
5923 						ASSERT(str->gld_minor >=
5924 						    GLD_MIN_CLONE_MINOR);
5925 						ASSERT(
5926 						    str->gld_multicnt == 0 ||
5927 						    str->gld_mcast);
5928 						nstr++;
5929 					}
5930 					ASSERT(vlan->gldv_nstreams == nstr);
5931 					nvlan++;
5932 				}
5933 			}
5934 			ASSERT(pvt->nvlan == nvlan);
5935 			GLDM_UNLOCK(mac);
5936 		}
5937 		mutex_exit(&dev->gld_devlock);
5938 	}
5939 	mutex_exit(&gld_device_list.gld_devlock);
5940 }
5941 #endif
5942