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