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