xref: /titanic_41/usr/src/uts/common/io/dls/dls_link.c (revision 0d6bb4c6728fd20087fe25f4028a3838250e6e9c)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Data-Link Services Module
28  */
29 
30 #include	<sys/sysmacros.h>
31 #include	<sys/strsubr.h>
32 #include	<sys/strsun.h>
33 #include	<sys/vlan.h>
34 #include	<sys/dld_impl.h>
35 #include	<sys/sdt.h>
36 #include	<sys/atomic.h>
37 
38 static kmem_cache_t	*i_dls_link_cachep;
39 mod_hash_t		*i_dls_link_hash;
40 static uint_t		i_dls_link_count;
41 
42 #define		LINK_HASHSZ	67	/* prime */
43 #define		IMPL_HASHSZ	67	/* prime */
44 
45 /*
46  * Construct a hash key encompassing both DLSAP value and VLAN idenitifier.
47  */
48 #define	MAKE_KEY(_sap)						\
49 	((mod_hash_key_t)(uintptr_t)((_sap) << VLAN_ID_SIZE))
50 
51 #define	DLS_STRIP_PADDING(pktsize, p) {			\
52 	if (pktsize != 0) {				\
53 		ssize_t delta = pktsize - msgdsize(p);	\
54 							\
55 		if (delta < 0)				\
56 			(void) adjmsg(p, delta);	\
57 	}						\
58 }
59 
60 /*
61  * Private functions.
62  */
63 
64 /*ARGSUSED*/
65 static int
i_dls_link_constructor(void * buf,void * arg,int kmflag)66 i_dls_link_constructor(void *buf, void *arg, int kmflag)
67 {
68 	dls_link_t	*dlp = buf;
69 	char		name[MAXNAMELEN];
70 
71 	bzero(buf, sizeof (dls_link_t));
72 
73 	(void) snprintf(name, MAXNAMELEN, "dls_link_t_%p_hash", buf);
74 	dlp->dl_str_hash = mod_hash_create_idhash(name, IMPL_HASHSZ,
75 	    mod_hash_null_valdtor);
76 
77 	return (0);
78 }
79 
80 /*ARGSUSED*/
81 static void
i_dls_link_destructor(void * buf,void * arg)82 i_dls_link_destructor(void *buf, void *arg)
83 {
84 	dls_link_t	*dlp = buf;
85 
86 	ASSERT(dlp->dl_ref == 0);
87 	ASSERT(dlp->dl_mh == NULL);
88 	ASSERT(dlp->dl_mah == NULL);
89 	ASSERT(dlp->dl_unknowns == 0);
90 
91 	mod_hash_destroy_idhash(dlp->dl_str_hash);
92 	dlp->dl_str_hash = NULL;
93 
94 }
95 
96 /*
97  * - Parse the mac header information of the given packet.
98  * - Strip the padding and skip over the header. Note that because some
99  *   DLS consumers only check the db_ref count of the first mblk, we
100  *   pullup the message into a single mblk. Because the original message
101  *   is freed as the result of message pulling up, mac_vlan_header_info()
102  *   is called again to update the mhi_saddr and mhi_daddr pointers in the
103  *   mhip. Further, the mac_vlan_header_info() function ensures that the
104  *   size of the pulled message is greater than the MAC header size,
105  *   therefore we can directly advance b_rptr to point at the payload.
106  *
107  * We choose to use a macro for performance reasons.
108  */
109 #define	DLS_PREPARE_PKT(mh, mp, mhip, err) {				\
110 	mblk_t *nextp = (mp)->b_next;					\
111 	if (((err) = mac_vlan_header_info((mh), (mp), (mhip))) == 0) {	\
112 		DLS_STRIP_PADDING((mhip)->mhi_pktsize, (mp));		\
113 		if (MBLKL((mp)) < (mhip)->mhi_hdrsize) {		\
114 			mblk_t *newmp;					\
115 			if ((newmp = msgpullup((mp), -1)) == NULL) {	\
116 				(err) = EINVAL;				\
117 			} else {					\
118 				(mp)->b_next = NULL;			\
119 				freemsg((mp));				\
120 				(mp) = newmp;				\
121 				VERIFY(mac_vlan_header_info((mh),	\
122 				    (mp), (mhip)) == 0);		\
123 				(mp)->b_next = nextp;			\
124 				(mp)->b_rptr += (mhip)->mhi_hdrsize;	\
125 			}						\
126 		} else {						\
127 			(mp)->b_rptr += (mhip)->mhi_hdrsize;		\
128 		}							\
129 	}								\
130 }
131 
132 /*
133  * Truncate the chain starting at mp such that all packets in the chain
134  * have identical source and destination addresses, saps, and tag types
135  * (see below).  It returns a pointer to the mblk following the chain,
136  * NULL if there is no further packet following the processed chain.
137  * The countp argument is set to the number of valid packets in the chain.
138  * Note that the whole MAC header (including the VLAN tag if any) in each
139  * packet will be stripped.
140  */
141 static mblk_t *
i_dls_link_subchain(dls_link_t * dlp,mblk_t * mp,const mac_header_info_t * mhip,uint_t * countp)142 i_dls_link_subchain(dls_link_t *dlp, mblk_t *mp, const mac_header_info_t *mhip,
143     uint_t *countp)
144 {
145 	mblk_t		*prevp;
146 	uint_t		npacket = 1;
147 	size_t		addr_size = dlp->dl_mip->mi_addr_length;
148 	uint16_t	vid = VLAN_ID(mhip->mhi_tci);
149 	uint16_t	pri = VLAN_PRI(mhip->mhi_tci);
150 
151 	/*
152 	 * Compare with subsequent headers until we find one that has
153 	 * differing header information. After checking each packet
154 	 * strip padding and skip over the header.
155 	 */
156 	for (prevp = mp; (mp = mp->b_next) != NULL; prevp = mp) {
157 		mac_header_info_t cmhi;
158 		uint16_t cvid, cpri;
159 		int err;
160 
161 		DLS_PREPARE_PKT(dlp->dl_mh, mp, &cmhi, err);
162 		if (err != 0)
163 			break;
164 
165 		prevp->b_next = mp;
166 
167 		/*
168 		 * The source, destination, sap, vlan tag must all match in
169 		 * a given subchain.
170 		 */
171 		if (mhip->mhi_saddr == NULL || cmhi.mhi_saddr == NULL ||
172 		    memcmp(mhip->mhi_daddr, cmhi.mhi_daddr, addr_size) != 0 ||
173 		    memcmp(mhip->mhi_saddr, cmhi.mhi_saddr, addr_size) != 0 ||
174 		    mhip->mhi_bindsap != cmhi.mhi_bindsap) {
175 			/*
176 			 * Note that we don't need to restore the padding.
177 			 */
178 			mp->b_rptr -= cmhi.mhi_hdrsize;
179 			break;
180 		}
181 
182 		cvid = VLAN_ID(cmhi.mhi_tci);
183 		cpri = VLAN_PRI(cmhi.mhi_tci);
184 
185 		/*
186 		 * There are several types of packets. Packets don't match
187 		 * if they are classified to different type or if they are
188 		 * VLAN packets but belong to different VLANs:
189 		 *
190 		 * packet type		tagged		vid		pri
191 		 * ---------------------------------------------------------
192 		 * untagged		No		zero		zero
193 		 * VLAN packets		Yes		non-zero	-
194 		 * priority tagged	Yes		zero		non-zero
195 		 * 0 tagged		Yes		zero		zero
196 		 */
197 		if ((mhip->mhi_istagged != cmhi.mhi_istagged) ||
198 		    (vid != cvid) || ((vid == VLAN_ID_NONE) &&
199 		    (((pri == 0) && (cpri != 0)) ||
200 		    ((pri != 0) && (cpri == 0))))) {
201 			mp->b_rptr -= cmhi.mhi_hdrsize;
202 			break;
203 		}
204 
205 		npacket++;
206 	}
207 
208 	/*
209 	 * Break the chain at this point and return a pointer to the next
210 	 * sub-chain.
211 	 */
212 	prevp->b_next = NULL;
213 	*countp = npacket;
214 	return (mp);
215 }
216 
217 /* ARGSUSED */
218 static int
i_dls_head_hold(mod_hash_key_t key,mod_hash_val_t val)219 i_dls_head_hold(mod_hash_key_t key, mod_hash_val_t val)
220 {
221 	dls_head_t *dhp = (dls_head_t *)val;
222 
223 	/*
224 	 * The lock order is  mod_hash's internal lock -> dh_lock as in the
225 	 * call to i_dls_link_rx -> mod_hash_find_cb_rval -> i_dls_head_hold
226 	 */
227 	mutex_enter(&dhp->dh_lock);
228 	if (dhp->dh_removing) {
229 		mutex_exit(&dhp->dh_lock);
230 		return (-1);
231 	}
232 	dhp->dh_ref++;
233 	mutex_exit(&dhp->dh_lock);
234 	return (0);
235 }
236 
237 void
i_dls_head_rele(dls_head_t * dhp)238 i_dls_head_rele(dls_head_t *dhp)
239 {
240 	mutex_enter(&dhp->dh_lock);
241 	dhp->dh_ref--;
242 	if (dhp->dh_ref == 0 && dhp->dh_removing != 0)
243 		cv_broadcast(&dhp->dh_cv);
244 	mutex_exit(&dhp->dh_lock);
245 }
246 
247 static dls_head_t *
i_dls_head_alloc(mod_hash_key_t key)248 i_dls_head_alloc(mod_hash_key_t key)
249 {
250 	dls_head_t	*dhp;
251 
252 	dhp = kmem_zalloc(sizeof (dls_head_t), KM_SLEEP);
253 	dhp->dh_key = key;
254 	return (dhp);
255 }
256 
257 static void
i_dls_head_free(dls_head_t * dhp)258 i_dls_head_free(dls_head_t *dhp)
259 {
260 	ASSERT(dhp->dh_ref == 0);
261 	kmem_free(dhp, sizeof (dls_head_t));
262 }
263 
264 /*
265  * Try to send mp up to the streams of the given sap and vid. Return B_TRUE
266  * if this message is sent to any streams.
267  * Note that this function will copy the message chain and the original
268  * mp will remain valid after this function
269  */
270 static uint_t
i_dls_link_rx_func(dls_link_t * dlp,mac_resource_handle_t mrh,mac_header_info_t * mhip,mblk_t * mp,uint32_t sap,boolean_t (* acceptfunc)())271 i_dls_link_rx_func(dls_link_t *dlp, mac_resource_handle_t mrh,
272     mac_header_info_t *mhip, mblk_t *mp, uint32_t sap,
273     boolean_t (*acceptfunc)())
274 {
275 	mod_hash_t	*hash = dlp->dl_str_hash;
276 	mod_hash_key_t	key;
277 	dls_head_t	*dhp;
278 	dld_str_t	*dsp;
279 	mblk_t		*nmp;
280 	dls_rx_t	ds_rx;
281 	void		*ds_rx_arg;
282 	uint_t		naccepted = 0;
283 	int		rval;
284 
285 	/*
286 	 * Construct a hash key from the VLAN identifier and the
287 	 * DLSAP that represents dld_str_t in promiscuous mode.
288 	 */
289 	key = MAKE_KEY(sap);
290 
291 	/*
292 	 * Search the hash table for dld_str_t eligible to receive
293 	 * a packet chain for this DLSAP/VLAN combination. The mod hash's
294 	 * internal lock serializes find/insert/remove from the mod hash list.
295 	 * Incrementing the dh_ref (while holding the mod hash lock) ensures
296 	 * dls_link_remove will wait for the upcall to finish.
297 	 */
298 	if (mod_hash_find_cb_rval(hash, key, (mod_hash_val_t *)&dhp,
299 	    i_dls_head_hold, &rval) != 0 || (rval != 0)) {
300 		return (B_FALSE);
301 	}
302 
303 	/*
304 	 * Find dld_str_t that will accept the sub-chain.
305 	 */
306 	for (dsp = dhp->dh_list; dsp != NULL; dsp = dsp->ds_next) {
307 		if (!acceptfunc(dsp, mhip, &ds_rx, &ds_rx_arg))
308 			continue;
309 
310 		/*
311 		 * We have at least one acceptor.
312 		 */
313 		naccepted++;
314 
315 		/*
316 		 * There will normally be at least more dld_str_t
317 		 * (since we've yet to check for non-promiscuous
318 		 * dld_str_t) so dup the sub-chain.
319 		 */
320 		if ((nmp = copymsgchain(mp)) != NULL)
321 			ds_rx(ds_rx_arg, mrh, nmp, mhip);
322 	}
323 
324 	/*
325 	 * Release the hold on the dld_str_t chain now that we have
326 	 * finished walking it.
327 	 */
328 	i_dls_head_rele(dhp);
329 	return (naccepted);
330 }
331 
332 /* ARGSUSED */
333 void
i_dls_link_rx(void * arg,mac_resource_handle_t mrh,mblk_t * mp,boolean_t loopback)334 i_dls_link_rx(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
335     boolean_t loopback)
336 {
337 	dls_link_t			*dlp = arg;
338 	mod_hash_t			*hash = dlp->dl_str_hash;
339 	mblk_t				*nextp;
340 	mac_header_info_t		mhi;
341 	dls_head_t			*dhp;
342 	dld_str_t			*dsp;
343 	dld_str_t			*ndsp;
344 	mblk_t				*nmp;
345 	mod_hash_key_t			key;
346 	uint_t				npacket;
347 	boolean_t			accepted;
348 	dls_rx_t			ds_rx, nds_rx;
349 	void				*ds_rx_arg, *nds_rx_arg;
350 	uint16_t			vid;
351 	int				err, rval;
352 
353 	/*
354 	 * Walk the packet chain.
355 	 */
356 	for (; mp != NULL; mp = nextp) {
357 		/*
358 		 * Wipe the accepted state.
359 		 */
360 		accepted = B_FALSE;
361 
362 		DLS_PREPARE_PKT(dlp->dl_mh, mp, &mhi, err);
363 		if (err != 0) {
364 			atomic_inc_32(&(dlp->dl_unknowns));
365 			nextp = mp->b_next;
366 			mp->b_next = NULL;
367 			freemsg(mp);
368 			continue;
369 		}
370 
371 		/*
372 		 * Grab the longest sub-chain we can process as a single
373 		 * unit.
374 		 */
375 		nextp = i_dls_link_subchain(dlp, mp, &mhi, &npacket);
376 		ASSERT(npacket != 0);
377 
378 		vid = VLAN_ID(mhi.mhi_tci);
379 
380 		if (mhi.mhi_istagged) {
381 			/*
382 			 * If it is tagged traffic, send it upstream to
383 			 * all dld_str_t which are attached to the physical
384 			 * link and bound to SAP 0x8100.
385 			 */
386 			if (i_dls_link_rx_func(dlp, mrh, &mhi, mp,
387 			    ETHERTYPE_VLAN, dls_accept) > 0) {
388 				accepted = B_TRUE;
389 			}
390 
391 			/*
392 			 * Don't pass the packets up if they are tagged
393 			 * packets and:
394 			 *  - their VID and priority are both zero and the
395 			 *    original packet isn't using the PVID (invalid
396 			 *    packets).
397 			 *  - their sap is ETHERTYPE_VLAN and their VID is
398 			 *    zero as they have already been sent upstreams.
399 			 */
400 			if ((vid == VLAN_ID_NONE && !mhi.mhi_ispvid &&
401 			    VLAN_PRI(mhi.mhi_tci) == 0) ||
402 			    (mhi.mhi_bindsap == ETHERTYPE_VLAN &&
403 			    vid == VLAN_ID_NONE)) {
404 				freemsgchain(mp);
405 				goto loop;
406 			}
407 		}
408 
409 		/*
410 		 * Construct a hash key from the VLAN identifier and the
411 		 * DLSAP.
412 		 */
413 		key = MAKE_KEY(mhi.mhi_bindsap);
414 
415 		/*
416 		 * Search the has table for dld_str_t eligible to receive
417 		 * a packet chain for this DLSAP/VLAN combination.
418 		 */
419 		if (mod_hash_find_cb_rval(hash, key, (mod_hash_val_t *)&dhp,
420 		    i_dls_head_hold, &rval) != 0 || (rval != 0)) {
421 			freemsgchain(mp);
422 			goto loop;
423 		}
424 
425 		/*
426 		 * Find the first dld_str_t that will accept the sub-chain.
427 		 */
428 		for (dsp = dhp->dh_list; dsp != NULL; dsp = dsp->ds_next)
429 			if (dls_accept(dsp, &mhi, &ds_rx, &ds_rx_arg))
430 				break;
431 
432 		/*
433 		 * If we did not find any dld_str_t willing to accept the
434 		 * sub-chain then throw it away.
435 		 */
436 		if (dsp == NULL) {
437 			i_dls_head_rele(dhp);
438 			freemsgchain(mp);
439 			goto loop;
440 		}
441 
442 		/*
443 		 * We have at least one acceptor.
444 		 */
445 		accepted = B_TRUE;
446 		for (;;) {
447 			/*
448 			 * Find the next dld_str_t that will accept the
449 			 * sub-chain.
450 			 */
451 			for (ndsp = dsp->ds_next; ndsp != NULL;
452 			    ndsp = ndsp->ds_next)
453 				if (dls_accept(ndsp, &mhi, &nds_rx,
454 				    &nds_rx_arg))
455 					break;
456 
457 			/*
458 			 * If there are no more dld_str_t that are willing
459 			 * to accept the sub-chain then we don't need to dup
460 			 * it before handing it to the current one.
461 			 */
462 			if (ndsp == NULL) {
463 				ds_rx(ds_rx_arg, mrh, mp, &mhi);
464 
465 				/*
466 				 * Since there are no more dld_str_t, we're
467 				 * done.
468 				 */
469 				break;
470 			}
471 
472 			/*
473 			 * There are more dld_str_t so dup the sub-chain.
474 			 */
475 			if ((nmp = copymsgchain(mp)) != NULL)
476 				ds_rx(ds_rx_arg, mrh, nmp, &mhi);
477 
478 			dsp = ndsp;
479 			ds_rx = nds_rx;
480 			ds_rx_arg = nds_rx_arg;
481 		}
482 
483 		/*
484 		 * Release the hold on the dld_str_t chain now that we have
485 		 * finished walking it.
486 		 */
487 		i_dls_head_rele(dhp);
488 
489 loop:
490 		/*
491 		 * If there were no acceptors then add the packet count to the
492 		 * 'unknown' count.
493 		 */
494 		if (!accepted)
495 			atomic_add_32(&(dlp->dl_unknowns), npacket);
496 	}
497 }
498 
499 /* ARGSUSED */
500 void
dls_rx_vlan_promisc(void * arg,mac_resource_handle_t mrh,mblk_t * mp,boolean_t loopback)501 dls_rx_vlan_promisc(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
502     boolean_t loopback)
503 {
504 	dld_str_t			*dsp = arg;
505 	dls_link_t			*dlp = dsp->ds_dlp;
506 	mac_header_info_t		mhi;
507 	dls_rx_t			ds_rx;
508 	void				*ds_rx_arg;
509 	int				err;
510 
511 	DLS_PREPARE_PKT(dlp->dl_mh, mp, &mhi, err);
512 	if (err != 0)
513 		goto drop;
514 
515 	/*
516 	 * If there is promiscuous handle for vlan, we filter out the untagged
517 	 * pkts and pkts that are not for the primary unicast address.
518 	 */
519 	if (dsp->ds_vlan_mph != NULL) {
520 		uint8_t prim_addr[MAXMACADDRLEN];
521 		size_t	addr_length = dsp->ds_mip->mi_addr_length;
522 
523 		if (!(mhi.mhi_istagged))
524 			goto drop;
525 		ASSERT(dsp->ds_mh != NULL);
526 		mac_unicast_primary_get(dsp->ds_mh, (uint8_t *)prim_addr);
527 		if (memcmp(mhi.mhi_daddr, prim_addr, addr_length) != 0)
528 			goto drop;
529 
530 		if (!dls_accept(dsp, &mhi, &ds_rx, &ds_rx_arg))
531 			goto drop;
532 
533 		ds_rx(ds_rx_arg, NULL, mp, &mhi);
534 		return;
535 	}
536 
537 drop:
538 	atomic_inc_32(&dlp->dl_unknowns);
539 	freemsg(mp);
540 }
541 
542 /* ARGSUSED */
543 void
dls_rx_promisc(void * arg,mac_resource_handle_t mrh,mblk_t * mp,boolean_t loopback)544 dls_rx_promisc(void *arg, mac_resource_handle_t mrh, mblk_t *mp,
545     boolean_t loopback)
546 {
547 	dld_str_t			*dsp = arg;
548 	dls_link_t			*dlp = dsp->ds_dlp;
549 	mac_header_info_t		mhi;
550 	dls_rx_t			ds_rx;
551 	void				*ds_rx_arg;
552 	int				err;
553 	dls_head_t			*dhp;
554 	mod_hash_key_t			key;
555 
556 	DLS_PREPARE_PKT(dlp->dl_mh, mp, &mhi, err);
557 	if (err != 0)
558 		goto drop;
559 
560 	/*
561 	 * In order to filter out sap pkt that no dls channel listens, search
562 	 * the hash table trying to find a dld_str_t eligible to receive the pkt
563 	 */
564 	if ((dsp->ds_promisc & DLS_PROMISC_SAP) == 0) {
565 		key = MAKE_KEY(mhi.mhi_bindsap);
566 		if (mod_hash_find(dsp->ds_dlp->dl_str_hash, key,
567 		    (mod_hash_val_t *)&dhp) != 0)
568 			goto drop;
569 	}
570 
571 	if (!dls_accept_promisc(dsp, &mhi, &ds_rx, &ds_rx_arg, loopback))
572 		goto drop;
573 
574 	ds_rx(ds_rx_arg, NULL, mp, &mhi);
575 	return;
576 
577 drop:
578 	atomic_inc_32(&dlp->dl_unknowns);
579 	freemsg(mp);
580 }
581 
582 static void
i_dls_link_destroy(dls_link_t * dlp)583 i_dls_link_destroy(dls_link_t *dlp)
584 {
585 	ASSERT(dlp->dl_nactive == 0);
586 	ASSERT(dlp->dl_impl_count == 0);
587 	ASSERT(dlp->dl_zone_ref == 0);
588 
589 	/*
590 	 * Free the structure back to the cache.
591 	 */
592 	if (dlp->dl_mch != NULL)
593 		mac_client_close(dlp->dl_mch, 0);
594 
595 	if (dlp->dl_mh != NULL) {
596 		ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
597 		mac_close(dlp->dl_mh);
598 	}
599 
600 	dlp->dl_mh = NULL;
601 	dlp->dl_mch = NULL;
602 	dlp->dl_mip = NULL;
603 	dlp->dl_unknowns = 0;
604 	dlp->dl_nonip_cnt = 0;
605 	kmem_cache_free(i_dls_link_cachep, dlp);
606 }
607 
608 static int
i_dls_link_create(const char * name,dls_link_t ** dlpp)609 i_dls_link_create(const char *name, dls_link_t **dlpp)
610 {
611 	dls_link_t		*dlp;
612 	int			err;
613 
614 	/*
615 	 * Allocate a new dls_link_t structure.
616 	 */
617 	dlp = kmem_cache_alloc(i_dls_link_cachep, KM_SLEEP);
618 
619 	/*
620 	 * Name the dls_link_t after the MAC interface it represents.
621 	 */
622 	(void) strlcpy(dlp->dl_name, name, sizeof (dlp->dl_name));
623 
624 	/*
625 	 * First reference; hold open the MAC interface.
626 	 */
627 	ASSERT(dlp->dl_mh == NULL);
628 	err = mac_open(dlp->dl_name, &dlp->dl_mh);
629 	if (err != 0)
630 		goto bail;
631 
632 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
633 	dlp->dl_mip = mac_info(dlp->dl_mh);
634 
635 	/* DLS is the "primary" MAC client */
636 	ASSERT(dlp->dl_mch == NULL);
637 
638 	err = mac_client_open(dlp->dl_mh, &dlp->dl_mch, NULL,
639 	    MAC_OPEN_FLAGS_USE_DATALINK_NAME);
640 	if (err != 0)
641 		goto bail;
642 
643 	DTRACE_PROBE2(dls__primary__client, char *, dlp->dl_name, void *,
644 	    dlp->dl_mch);
645 
646 	*dlpp = dlp;
647 	return (0);
648 
649 bail:
650 	i_dls_link_destroy(dlp);
651 	return (err);
652 }
653 
654 /*
655  * Module initialization functions.
656  */
657 
658 void
dls_link_init(void)659 dls_link_init(void)
660 {
661 	/*
662 	 * Create a kmem_cache of dls_link_t structures.
663 	 */
664 	i_dls_link_cachep = kmem_cache_create("dls_link_cache",
665 	    sizeof (dls_link_t), 0, i_dls_link_constructor,
666 	    i_dls_link_destructor, NULL, NULL, NULL, 0);
667 	ASSERT(i_dls_link_cachep != NULL);
668 
669 	/*
670 	 * Create a dls_link_t hash table and associated lock.
671 	 */
672 	i_dls_link_hash = mod_hash_create_extended("dls_link_hash",
673 	    IMPL_HASHSZ, mod_hash_null_keydtor, mod_hash_null_valdtor,
674 	    mod_hash_bystr, NULL, mod_hash_strkey_cmp, KM_SLEEP);
675 	i_dls_link_count = 0;
676 }
677 
678 int
dls_link_fini(void)679 dls_link_fini(void)
680 {
681 	if (i_dls_link_count > 0)
682 		return (EBUSY);
683 
684 	/*
685 	 * Destroy the kmem_cache.
686 	 */
687 	kmem_cache_destroy(i_dls_link_cachep);
688 
689 	/*
690 	 * Destroy the hash table and associated lock.
691 	 */
692 	mod_hash_destroy_hash(i_dls_link_hash);
693 	return (0);
694 }
695 
696 /*
697  * Exported functions.
698  */
699 
700 static int
dls_link_hold_common(const char * name,dls_link_t ** dlpp,boolean_t create)701 dls_link_hold_common(const char *name, dls_link_t **dlpp, boolean_t create)
702 {
703 	dls_link_t		*dlp;
704 	int			err;
705 
706 	/*
707 	 * Look up a dls_link_t corresponding to the given macname in the
708 	 * global hash table. The i_dls_link_hash itself is protected by the
709 	 * mod_hash package's internal lock which synchronizes
710 	 * find/insert/remove into the global mod_hash list. Assumes that
711 	 * inserts and removes are single threaded on a per mac end point
712 	 * by the mac perimeter.
713 	 */
714 	if ((err = mod_hash_find(i_dls_link_hash, (mod_hash_key_t)name,
715 	    (mod_hash_val_t *)&dlp)) == 0)
716 		goto done;
717 
718 	ASSERT(err == MH_ERR_NOTFOUND);
719 	if (!create)
720 		return (ENOENT);
721 
722 	/*
723 	 * We didn't find anything so we need to create one.
724 	 */
725 	if ((err = i_dls_link_create(name, &dlp)) != 0)
726 		return (err);
727 
728 	/*
729 	 * Insert the dls_link_t.
730 	 */
731 	err = mod_hash_insert(i_dls_link_hash, (mod_hash_key_t)dlp->dl_name,
732 	    (mod_hash_val_t)dlp);
733 	ASSERT(err == 0);
734 
735 	atomic_inc_32(&i_dls_link_count);
736 	ASSERT(i_dls_link_count != 0);
737 
738 done:
739 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
740 	/*
741 	 * Bump the reference count and hand back the reference.
742 	 */
743 	dlp->dl_ref++;
744 	*dlpp = dlp;
745 	return (0);
746 }
747 
748 int
dls_link_hold_create(const char * name,dls_link_t ** dlpp)749 dls_link_hold_create(const char *name, dls_link_t **dlpp)
750 {
751 	return (dls_link_hold_common(name, dlpp, B_TRUE));
752 }
753 
754 int
dls_link_hold(const char * name,dls_link_t ** dlpp)755 dls_link_hold(const char *name, dls_link_t **dlpp)
756 {
757 	return (dls_link_hold_common(name, dlpp, B_FALSE));
758 }
759 
760 dev_info_t *
dls_link_devinfo(dev_t dev)761 dls_link_devinfo(dev_t dev)
762 {
763 	dls_link_t	*dlp;
764 	dev_info_t	*dip;
765 	char	macname[MAXNAMELEN];
766 	char	*drv;
767 	mac_perim_handle_t	mph;
768 
769 	if ((drv = ddi_major_to_name(getmajor(dev))) == NULL)
770 		return (NULL);
771 	(void) snprintf(macname, MAXNAMELEN, "%s%d", drv,
772 	    DLS_MINOR2INST(getminor(dev)));
773 
774 	/*
775 	 * The code below assumes that the name constructed above is the
776 	 * macname. This is not the case for legacy devices. Currently this
777 	 * is ok because this function is only called in the getinfo(9e) path,
778 	 * which for a legacy device would directly end up in the driver's
779 	 * getinfo, rather than here
780 	 */
781 	if (mac_perim_enter_by_macname(macname, &mph) != 0)
782 		return (NULL);
783 
784 	if (dls_link_hold(macname, &dlp) != 0) {
785 		mac_perim_exit(mph);
786 		return (NULL);
787 	}
788 
789 	dip = mac_devinfo_get(dlp->dl_mh);
790 	dls_link_rele(dlp);
791 	mac_perim_exit(mph);
792 
793 	return (dip);
794 }
795 
796 dev_t
dls_link_dev(dls_link_t * dlp)797 dls_link_dev(dls_link_t *dlp)
798 {
799 	return (makedevice(ddi_driver_major(mac_devinfo_get(dlp->dl_mh)),
800 	    mac_minor(dlp->dl_mh)));
801 }
802 
803 void
dls_link_rele(dls_link_t * dlp)804 dls_link_rele(dls_link_t *dlp)
805 {
806 	mod_hash_val_t	val;
807 
808 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
809 	/*
810 	 * Check if there are any more references.
811 	 */
812 	if (--dlp->dl_ref == 0) {
813 		(void) mod_hash_remove(i_dls_link_hash,
814 		    (mod_hash_key_t)dlp->dl_name, &val);
815 		ASSERT(dlp == (dls_link_t *)val);
816 
817 		/*
818 		 * Destroy the dls_link_t.
819 		 */
820 		i_dls_link_destroy(dlp);
821 		ASSERT(i_dls_link_count > 0);
822 		atomic_dec_32(&i_dls_link_count);
823 	}
824 }
825 
826 int
dls_link_rele_by_name(const char * name)827 dls_link_rele_by_name(const char *name)
828 {
829 	dls_link_t		*dlp;
830 
831 	if (mod_hash_find(i_dls_link_hash, (mod_hash_key_t)name,
832 	    (mod_hash_val_t *)&dlp) != 0)
833 		return (ENOENT);
834 
835 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
836 
837 	/*
838 	 * Must fail detach if mac client is busy.
839 	 */
840 	ASSERT(dlp->dl_ref > 0 && dlp->dl_mch != NULL);
841 	if (mac_link_has_flows(dlp->dl_mch))
842 		return (ENOTEMPTY);
843 
844 	dls_link_rele(dlp);
845 	return (0);
846 }
847 
848 int
dls_link_setzid(const char * name,zoneid_t zid)849 dls_link_setzid(const char *name, zoneid_t zid)
850 {
851 	dls_link_t	*dlp;
852 	int		err = 0;
853 	zoneid_t	old_zid;
854 
855 	if ((err = dls_link_hold_create(name, &dlp)) != 0)
856 		return (err);
857 
858 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
859 
860 	if ((old_zid = dlp->dl_zid) == zid)
861 		goto done;
862 
863 	/*
864 	 * Check whether this dlp is used by its own zone.  If yes, we cannot
865 	 * change its zoneid.
866 	 */
867 	if (dlp->dl_zone_ref != 0) {
868 		err = EBUSY;
869 		goto done;
870 	}
871 
872 	dlp->dl_zid = zid;
873 
874 	if (zid == GLOBAL_ZONEID) {
875 		/*
876 		 * The link is moving from a non-global zone to the global
877 		 * zone, so we need to release the reference that was held
878 		 * when the link was originally assigned to the non-global
879 		 * zone.
880 		 */
881 		dls_link_rele(dlp);
882 	}
883 
884 done:
885 	/*
886 	 * We only keep the reference to this link open if the link has
887 	 * successfully moved from the global zone to a non-global zone.
888 	 */
889 	if (err != 0 || old_zid != GLOBAL_ZONEID)
890 		dls_link_rele(dlp);
891 	return (err);
892 }
893 
894 int
dls_link_getzid(const char * name,zoneid_t * zidp)895 dls_link_getzid(const char *name, zoneid_t *zidp)
896 {
897 	dls_link_t	*dlp;
898 	int		err = 0;
899 
900 	if ((err = dls_link_hold(name, &dlp)) != 0)
901 		return (err);
902 
903 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
904 
905 	*zidp = dlp->dl_zid;
906 
907 	dls_link_rele(dlp);
908 	return (0);
909 }
910 
911 void
dls_link_add(dls_link_t * dlp,uint32_t sap,dld_str_t * dsp)912 dls_link_add(dls_link_t *dlp, uint32_t sap, dld_str_t *dsp)
913 {
914 	mod_hash_t	*hash = dlp->dl_str_hash;
915 	mod_hash_key_t	key;
916 	dls_head_t	*dhp;
917 	dld_str_t	*p;
918 	int		err;
919 
920 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
921 
922 	/*
923 	 * Generate a hash key based on the sap.
924 	 */
925 	key = MAKE_KEY(sap);
926 
927 	/*
928 	 * Search the table for a list head with this key.
929 	 */
930 	if ((err = mod_hash_find(hash, key, (mod_hash_val_t *)&dhp)) != 0) {
931 		ASSERT(err == MH_ERR_NOTFOUND);
932 
933 		dhp = i_dls_head_alloc(key);
934 		err = mod_hash_insert(hash, key, (mod_hash_val_t)dhp);
935 		ASSERT(err == 0);
936 	}
937 
938 	/*
939 	 * Add the dld_str_t to the head of the list. List walkers in
940 	 * i_dls_link_rx_* bump up dh_ref to ensure the list does not change
941 	 * while they walk the list. The membar below ensures that list walkers
942 	 * see exactly the old list or the new list.
943 	 */
944 	ASSERT(dsp->ds_next == NULL);
945 	p = dhp->dh_list;
946 	dsp->ds_next = p;
947 
948 	membar_producer();
949 
950 	dhp->dh_list = dsp;
951 
952 	/*
953 	 * Save a pointer to the list head.
954 	 */
955 	dsp->ds_head = dhp;
956 	dlp->dl_impl_count++;
957 }
958 
959 void
dls_link_remove(dls_link_t * dlp,dld_str_t * dsp)960 dls_link_remove(dls_link_t *dlp, dld_str_t *dsp)
961 {
962 	mod_hash_t	*hash = dlp->dl_str_hash;
963 	dld_str_t	**pp;
964 	dld_str_t	*p;
965 	dls_head_t	*dhp;
966 
967 	ASSERT(MAC_PERIM_HELD(dlp->dl_mh));
968 
969 	/*
970 	 * We set dh_removing here to tell the receive callbacks not to pass
971 	 * up packets anymore. Then wait till the current callbacks are done.
972 	 * This happens either in the close path or in processing the
973 	 * DL_UNBIND_REQ via a taskq thread, and it is ok to cv_wait in either.
974 	 * The dh_ref ensures there aren't and there won't be any upcalls
975 	 * walking or using the dh_list. The mod hash internal lock ensures
976 	 * that the insert/remove of the dls_head_t itself synchronizes with
977 	 * any i_dls_link_rx trying to locate it. The perimeter ensures that
978 	 * there isn't another simultaneous dls_link_add/remove.
979 	 */
980 	dhp = dsp->ds_head;
981 
982 	mutex_enter(&dhp->dh_lock);
983 	dhp->dh_removing = B_TRUE;
984 	while (dhp->dh_ref != 0)
985 		cv_wait(&dhp->dh_cv, &dhp->dh_lock);
986 	mutex_exit(&dhp->dh_lock);
987 
988 	/*
989 	 * Walk the list and remove the dld_str_t.
990 	 */
991 	for (pp = &dhp->dh_list; (p = *pp) != NULL; pp = &(p->ds_next)) {
992 		if (p == dsp)
993 			break;
994 	}
995 	ASSERT(p != NULL);
996 	*pp = p->ds_next;
997 	p->ds_next = NULL;
998 	p->ds_head = NULL;
999 
1000 	ASSERT(dlp->dl_impl_count != 0);
1001 	dlp->dl_impl_count--;
1002 
1003 	if (dhp->dh_list == NULL) {
1004 		mod_hash_val_t	val = NULL;
1005 
1006 		/*
1007 		 * The list is empty so remove the hash table entry.
1008 		 */
1009 		(void) mod_hash_remove(hash, dhp->dh_key, &val);
1010 		ASSERT(dhp == (dls_head_t *)val);
1011 		i_dls_head_free(dhp);
1012 	} else {
1013 		mutex_enter(&dhp->dh_lock);
1014 		dhp->dh_removing = B_FALSE;
1015 		mutex_exit(&dhp->dh_lock);
1016 	}
1017 }
1018