xref: /titanic_51/usr/src/uts/common/io/trill.c (revision bbaa8b60dd95d714741fc474adad3cf710ef4efd)
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 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  *  This module supports AF_TRILL sockets and TRILL layer-2 forwarding.
29  */
30 
31 #include <sys/strsubr.h>
32 #include <sys/socket.h>
33 #include <sys/socketvar.h>
34 #include <sys/modctl.h>
35 #include <sys/cmn_err.h>
36 #include <sys/tihdr.h>
37 #include <sys/strsun.h>
38 #include <sys/policy.h>
39 #include <sys/ethernet.h>
40 #include <sys/vlan.h>
41 #include <net/trill.h>
42 #include <net/if_dl.h>
43 #include <sys/mac.h>
44 #include <sys/mac_client.h>
45 #include <sys/mac_provider.h>
46 #include <sys/mac_client_priv.h>
47 #include <sys/sdt.h>
48 #include <sys/dls.h>
49 #include <sys/sunddi.h>
50 
51 #include "trill_impl.h"
52 
53 static void trill_del_all(trill_inst_t *, boolean_t);
54 static int trill_del_nick(trill_inst_t *, uint16_t, boolean_t);
55 static void trill_stop_recv(trill_sock_t *);
56 static void trill_ctrl_input(trill_sock_t *, mblk_t *, const uint8_t *,
57     uint16_t);
58 static trill_node_t *trill_node_lookup(trill_inst_t *, uint16_t);
59 static void trill_node_unref(trill_inst_t *, trill_node_t *);
60 static void trill_sock_unref(trill_sock_t *);
61 static void trill_kstats_init(trill_sock_t *, const char *);
62 
63 static list_t trill_inst_list;
64 static krwlock_t trill_inst_rwlock;
65 
66 static sock_lower_handle_t trill_create(int, int, int, sock_downcalls_t **,
67     uint_t *, int *, int, cred_t *);
68 
69 static smod_reg_t sinfo = {
70 	SOCKMOD_VERSION,
71 	"trill",
72 	SOCK_UC_VERSION,
73 	SOCK_DC_VERSION,
74 	trill_create,
75 	NULL,
76 };
77 
78 /* modldrv structure */
79 static struct modlsockmod sockmod = {
80 	&mod_sockmodops, "AF_TRILL socket module", &sinfo
81 };
82 
83 /* modlinkage structure */
84 static struct modlinkage ml = {
85 	MODREV_1,
86 	&sockmod,
87 	NULL
88 };
89 
90 #define	VALID_NICK(n)	((n) != RBRIDGE_NICKNAME_NONE && \
91 			(n) != RBRIDGE_NICKNAME_UNUSED)
92 
93 static mblk_t *
94 create_trill_header(trill_sock_t *tsock, mblk_t *mp, const uint8_t *daddr,
95     boolean_t trill_hdr_ok, boolean_t multidest, uint16_t tci,
96     size_t msglen)
97 {
98 	int extra_hdr_len;
99 	struct ether_vlan_header *ethvlanhdr;
100 	mblk_t *hdr_mp;
101 	uint16_t etype;
102 
103 	etype = msglen > 0 ? (uint16_t)msglen : ETHERTYPE_TRILL;
104 
105 	/* When sending on the PVID, we must not give a VLAN ID */
106 	if (tci == tsock->ts_link->bl_pvid)
107 		tci = TRILL_NO_TCI;
108 
109 	/*
110 	 * Create new Ethernet header and include additional space
111 	 * for writing TRILL header and/or VLAN tag.
112 	 */
113 	extra_hdr_len = (trill_hdr_ok ? 0 : sizeof (trill_header_t)) +
114 	    (tci != TRILL_NO_TCI ? sizeof (struct ether_vlan_extinfo) : 0);
115 	hdr_mp = mac_header(tsock->ts_link->bl_mh, daddr,
116 	    tci != TRILL_NO_TCI ? ETHERTYPE_VLAN : etype, mp, extra_hdr_len);
117 	if (hdr_mp == NULL) {
118 		freemsg(mp);
119 		return (NULL);
120 	}
121 
122 	if (tci != TRILL_NO_TCI) {
123 		/* LINTED: alignment */
124 		ethvlanhdr = (struct ether_vlan_header *)hdr_mp->b_rptr;
125 		ethvlanhdr->ether_tci = htons(tci);
126 		ethvlanhdr->ether_type = htons(etype);
127 		hdr_mp->b_wptr += sizeof (struct ether_vlan_extinfo);
128 	}
129 
130 	if (!trill_hdr_ok) {
131 		trill_header_t *thp;
132 		/* LINTED: alignment */
133 		thp = (trill_header_t *)hdr_mp->b_wptr;
134 		(void) memset(thp, 0, sizeof (trill_header_t));
135 		thp->th_hopcount = TRILL_DEFAULT_HOPS;
136 		thp->th_multidest = (multidest ? 1:0);
137 		hdr_mp->b_wptr += sizeof (trill_header_t);
138 	}
139 
140 	hdr_mp->b_cont = mp;
141 	return (hdr_mp);
142 }
143 
144 /*
145  * TRILL local recv function. TRILL data frames that should be received
146  * by the local system are decapsulated here and passed to bridging for
147  * learning and local system receive. Only called when we are the forwarder
148  * on the link (multi-dest frames) or the frame was destined for us.
149  */
150 static void
151 trill_recv_local(trill_sock_t *tsock, mblk_t *mp, uint16_t ingressnick)
152 {
153 	struct ether_header *inner_ethhdr;
154 
155 	/* LINTED: alignment */
156 	inner_ethhdr = (struct ether_header *)mp->b_rptr;
157 	DTRACE_PROBE1(trill__recv__local, struct ether_header *, inner_ethhdr);
158 
159 	DB_CKSUMFLAGS(mp) = 0;
160 	/*
161 	 * Transmit the decapsulated frame on the link via Bridging.
162 	 * Bridging does source address learning and appropriate forwarding.
163 	 */
164 	bridge_trill_decaps(tsock->ts_link, mp, ingressnick);
165 	KSPINCR(tks_decap);
166 }
167 
168 /*
169  * Determines the outgoing link to reach a RBridge having the given nick
170  * Assumes caller has acquired the trill instance rwlock.
171  */
172 static trill_sock_t *
173 find_trill_link(trill_inst_t *tip, datalink_id_t linkid)
174 {
175 	trill_sock_t *tsp = NULL;
176 
177 	ASSERT(RW_LOCK_HELD(&tip->ti_rwlock));
178 	for (tsp = list_head(&tip->ti_socklist); tsp != NULL;
179 	    tsp = list_next(&tip->ti_socklist, tsp)) {
180 		if (tsp->ts_link != NULL && tsp->ts_link->bl_linkid == linkid) {
181 			ASSERT(tsp->ts_link->bl_mh != NULL);
182 			ASSERT(!(tsp->ts_flags & TSF_SHUTDOWN));
183 			atomic_inc_uint(&tsp->ts_refs);
184 			break;
185 		}
186 	}
187 	return (tsp);
188 }
189 
190 /*
191  * TRILL destination forwarding function. Transmits the TRILL data packet
192  * to the next-hop, adjacent RBridge.  Consumes passed mblk_t.
193  */
194 static void
195 trill_dest_fwd(trill_inst_t *tip, mblk_t *fwd_mp, uint16_t adj_nick,
196     boolean_t has_trill_hdr, boolean_t multidest, uint16_t dtnick)
197 {
198 	trill_node_t *adj;
199 	trill_sock_t *tsock = NULL;
200 	trill_header_t *trillhdr;
201 	struct ether_header *ethhdr;
202 	int ethtype;
203 	int ethhdrlen;
204 
205 	adj = trill_node_lookup(tip, adj_nick);
206 	if (adj == NULL || ((tsock = adj->tn_tsp) == NULL))
207 		goto dest_fwd_fail;
208 
209 	ASSERT(tsock->ts_link != NULL);
210 	ASSERT(!(tsock->ts_flags & TSF_SHUTDOWN));
211 	ASSERT(adj->tn_ni != NULL);
212 
213 	DTRACE_PROBE3(trill__dest__fwd, uint16_t, adj_nick, trill_node_t,
214 	    adj, trill_sock_t, tsock);
215 
216 	/*
217 	 * For broadcast links by using the dest address of
218 	 * the RBridge to forward the frame should result in
219 	 * savings. When the link is a bridged LAN or there are
220 	 * many end stations the frame will not always be flooded.
221 	 */
222 	fwd_mp = create_trill_header(tsock, fwd_mp, adj->tn_ni->tni_adjsnpa,
223 	    has_trill_hdr, multidest, tsock->ts_desigvlan, 0);
224 	if (fwd_mp == NULL)
225 		goto dest_fwd_fail;
226 
227 	/* LINTED: alignment */
228 	ethhdr = (struct ether_header *)fwd_mp->b_rptr;
229 	ethtype = ntohs(ethhdr->ether_type);
230 	ASSERT(ethtype == ETHERTYPE_VLAN || ethtype == ETHERTYPE_TRILL);
231 
232 	/* Pullup Ethernet and TRILL header (w/o TRILL options) */
233 	ethhdrlen = sizeof (struct ether_header) +
234 	    (ethtype == ETHERTYPE_VLAN ? sizeof (struct ether_vlan_extinfo):0);
235 	if (!pullupmsg(fwd_mp, ethhdrlen + sizeof (trill_header_t)))
236 		goto dest_fwd_fail;
237 	/* LINTED: alignment */
238 	trillhdr = (struct trill_header *)(fwd_mp->b_rptr + ethhdrlen);
239 
240 	/* Update TRILL header with ingress and egress nicks for new frames */
241 	if (!has_trill_hdr) {
242 		/* We are creating a new TRILL frame */
243 		trillhdr->th_egressnick = (multidest ? dtnick:adj_nick);
244 		rw_enter(&tip->ti_rwlock, RW_READER);
245 		trillhdr->th_ingressnick = tip->ti_nick;
246 		rw_exit(&tip->ti_rwlock);
247 		if (!VALID_NICK(trillhdr->th_ingressnick))
248 			goto dest_fwd_fail;
249 	}
250 
251 	/* Set hop count and update header in packet */
252 	ASSERT(trillhdr->th_hopcount != 0);
253 	trillhdr->th_hopcount--;
254 
255 	/* Clear checksum flag and transmit frame on the link */
256 	DB_CKSUMFLAGS(fwd_mp) = 0;
257 	DTRACE_PROBE1(trill__dest__fwd__tx, trill_header_t *, &trillhdr);
258 	fwd_mp = bridge_trill_output(tsock->ts_link, fwd_mp);
259 	if (fwd_mp == NULL) {
260 		KSPINCR(tks_sent);
261 		KSPINCR(tks_forward);
262 	} else {
263 		freemsg(fwd_mp);
264 		KSPINCR(tks_drops);
265 	}
266 	trill_node_unref(tip, adj);
267 	return;
268 
269 dest_fwd_fail:
270 	if (adj != NULL)
271 		trill_node_unref(tip, adj);
272 	if (tsock != NULL)
273 		KSPINCR(tks_drops);
274 	freemsg(fwd_mp);
275 }
276 
277 /*
278  * TRILL multi-destination forwarding. Transmits the packet to the adjacencies
279  * on the distribution tree determined by the egress nick. Source addr (saddr)
280  * is NULL for new TRILL packets originating from us.
281  */
282 static void
283 trill_multidest_fwd(trill_inst_t *tip, mblk_t *mp, uint16_t egressnick,
284     uint16_t ingressnick, boolean_t is_trill_pkt, const uint8_t *saddr,
285     int inner_vlan, boolean_t free_mblk)
286 {
287 	int idx;
288 	uint16_t adjnick;
289 	trill_node_t *dest;
290 	trill_node_t *adj;
291 	mblk_t *fwd_mp;
292 	boolean_t nicksaved = B_FALSE;
293 	uint16_t adjnicksaved;
294 
295 	/* Lookup the egress nick info, this is the DT root */
296 	if ((dest = trill_node_lookup(tip, egressnick)) == NULL)
297 		goto fail_multidest_fwd;
298 
299 	/* Send a copy to all our adjacencies on the DT root  */
300 	ASSERT(dest->tn_ni);
301 	for (idx = 0; idx < dest->tn_ni->tni_adjcount; idx++) {
302 
303 		/* Check for a valid adjacency node */
304 		adjnick = TNI_ADJNICK(dest->tn_ni, idx);
305 		if (!VALID_NICK(adjnick) || ingressnick == adjnick ||
306 		    ((adj = trill_node_lookup(tip, adjnick)) == NULL))
307 			continue;
308 
309 		/* Do not forward back to adjacency that sent the pkt to us */
310 		ASSERT(adj->tn_ni != NULL);
311 		if ((saddr != NULL) &&
312 		    (memcmp(adj->tn_ni->tni_adjsnpa, saddr,
313 		    ETHERADDRL) == 0)) {
314 			trill_node_unref(tip, adj);
315 			continue;
316 		}
317 
318 		/* Check if adj is marked as reaching inner VLAN downstream */
319 		if ((inner_vlan != VLAN_ID_NONE) &&
320 		    !TRILL_VLANISSET(TNI_VLANFILTERMAP(dest->tn_ni, idx),
321 		    inner_vlan)) {
322 			trill_node_unref(tip, adj);
323 			DTRACE_PROBE4(trill__multi__dest__fwd__vlanfiltered,
324 			    uint16_t, adjnick, uint16_t, ingressnick,
325 			    uint16_t, egressnick, int, inner_vlan);
326 			continue;
327 		}
328 
329 		trill_node_unref(tip, adj);
330 
331 		/*
332 		 * Save the nick and look ahead to see if we should forward the
333 		 * frame to more adjacencies. We avoid doing a copy for this
334 		 * nick and use the passed mblk when we can consume the passed
335 		 * mblk.
336 		 */
337 		if (free_mblk && !nicksaved) {
338 			adjnicksaved = adjnick;
339 			nicksaved = B_TRUE;
340 			continue;
341 		}
342 
343 		fwd_mp = copymsg(mp);
344 		if (fwd_mp == NULL)
345 			break;
346 		DTRACE_PROBE2(trill__multi__dest__fwd, uint16_t,
347 		    adjnick, uint16_t, ingressnick);
348 		trill_dest_fwd(tip, fwd_mp, adjnick, is_trill_pkt,
349 		    B_TRUE, egressnick);
350 	}
351 	trill_node_unref(tip, dest);
352 
353 	if (nicksaved) {
354 		ASSERT(free_mblk);
355 		DTRACE_PROBE2(trill__multi__dest__fwd, uint16_t,
356 		    adjnicksaved, uint16_t, ingressnick);
357 		trill_dest_fwd(tip, mp, adjnicksaved, is_trill_pkt,
358 		    B_TRUE, egressnick);
359 		return;
360 	}
361 
362 fail_multidest_fwd:
363 	DTRACE_PROBE2(trill__multi__dest__fwd__fail, uint16_t,
364 	    egressnick, uint16_t, ingressnick);
365 	if (free_mblk) {
366 		freemsg(mp);
367 	}
368 }
369 
370 /*
371  * TRILL data receive function. Forwards the received frame if necessary
372  * and also determines if the received frame should be consumed locally.
373  * Consumes passed mblk.
374  */
375 static void
376 trill_recv(trill_sock_t *tsock, mblk_t *mp, const uint8_t *mpsaddr)
377 {
378 	trill_header_t *trillhdr;
379 	trill_node_t *dest = NULL;
380 	trill_node_t *source = NULL;
381 	trill_node_t *adj;
382 	uint16_t ournick, adjnick, treeroot;
383 	struct ether_header *ethhdr;
384 	trill_inst_t *tip = tsock->ts_tip;
385 	uint8_t srcaddr[ETHERADDRL];
386 	size_t trillhdrlen;
387 	int inner_vlan = VLAN_ID_NONE;
388 	int tci;
389 	int idx;
390 	size_t min_size;
391 
392 	/* Copy Ethernet source address before modifying packet */
393 	(void) memcpy(srcaddr, mpsaddr, ETHERADDRL);
394 
395 	/* Pull up TRILL header if necessary. */
396 	min_size = sizeof (trill_header_t);
397 	if ((MBLKL(mp) < min_size ||
398 	    !IS_P2ALIGNED(mp->b_rptr, TRILL_HDR_ALIGN)) &&
399 	    !pullupmsg(mp, min_size))
400 		goto fail;
401 
402 	/* LINTED: alignment */
403 	trillhdr = (trill_header_t *)mp->b_rptr;
404 	if (trillhdr->th_version != TRILL_PROTOCOL_VERS) {
405 		DTRACE_PROBE1(trill__recv__wrongversion,
406 		    trill_header_t *, trillhdr);
407 		goto fail;
408 	}
409 
410 	/* Drop if unknown or invalid nickname */
411 	if (!VALID_NICK(trillhdr->th_egressnick) ||
412 	    !VALID_NICK(trillhdr->th_ingressnick)) {
413 		DTRACE_PROBE1(trill__recv__invalidnick,
414 		    trill_header_t *, trillhdr);
415 		goto fail;
416 	}
417 
418 	rw_enter(&tip->ti_rwlock, RW_READER);
419 	ournick = tip->ti_nick;
420 	treeroot = tip->ti_treeroot;
421 	rw_exit(&tip->ti_rwlock);
422 	/* Drop if we received a packet with our nick as ingress */
423 	if (trillhdr->th_ingressnick == ournick)
424 		goto fail;
425 
426 	/* Re-pull any TRILL options and inner Ethernet header */
427 	min_size += GET_TRILL_OPTS_LEN(trillhdr) * sizeof (uint32_t) +
428 	    sizeof (struct ether_header);
429 	if (MBLKL(mp) < min_size) {
430 		if (!pullupmsg(mp, min_size))
431 			goto fail;
432 		/* LINTED: alignment */
433 		trillhdr = (trill_header_t *)mp->b_rptr;
434 	}
435 	trillhdrlen = sizeof (trill_header_t) +
436 	    (GET_TRILL_OPTS_LEN(trillhdr) * sizeof (uint32_t));
437 
438 	/*
439 	 * Get the inner Ethernet header, plus the inner VLAN header if there
440 	 * is one.
441 	 */
442 	/* LINTED: alignment */
443 	ethhdr = (struct ether_header *)(mp->b_rptr + trillhdrlen);
444 	if (ethhdr->ether_type == htons(ETHERTYPE_VLAN)) {
445 		min_size += sizeof (struct ether_vlan_extinfo);
446 		if (MBLKL(mp) < min_size) {
447 			if (!pullupmsg(mp, min_size))
448 				goto fail;
449 			/* LINTED: alignment */
450 			trillhdr = (trill_header_t *)mp->b_rptr;
451 			/* LINTED: alignment */
452 			ethhdr = (struct ether_header *)(mp->b_rptr +
453 			    trillhdrlen);
454 		}
455 
456 		tci = ntohs(((struct ether_vlan_header *)ethhdr)->ether_tci);
457 		inner_vlan = VLAN_ID(tci);
458 	}
459 
460 	/* Known/single destination forwarding. */
461 	if (!trillhdr->th_multidest) {
462 
463 		/* Inner MacDA must be unicast */
464 		if (ethhdr->ether_dhost.ether_addr_octet[0] & 1)
465 			goto fail;
466 
467 		/* Ingress and Egress nicks must be different */
468 		if (trillhdr->th_egressnick == trillhdr->th_ingressnick)
469 			goto fail;
470 
471 		DTRACE_PROBE1(trill__recv__singledest,
472 		    trill_header_t *, trillhdr);
473 		if (trillhdr->th_egressnick == ournick) {
474 			mp->b_rptr += trillhdrlen;
475 			trill_recv_local(tsock, mp, trillhdr->th_ingressnick);
476 		} else if (trillhdr->th_hopcount > 0) {
477 			trill_dest_fwd(tip, mp, trillhdr->th_egressnick,
478 			    B_TRUE, B_FALSE, RBRIDGE_NICKNAME_NONE);
479 		} else {
480 			goto fail;
481 		}
482 		return;
483 	}
484 
485 	/*
486 	 * Multi-destination frame: perform checks verifying we have
487 	 * received a valid multi-destination frame before receiving the
488 	 * frame locally and forwarding the frame to other RBridges.
489 	 *
490 	 * Check if we received this multi-destination frame on a
491 	 * adjacency in the distribution tree indicated by the frame's
492 	 * egress nickname.
493 	 */
494 	if ((dest = trill_node_lookup(tip, trillhdr->th_egressnick)) == NULL)
495 		goto fail;
496 	for (idx = 0; idx < dest->tn_ni->tni_adjcount; idx++) {
497 		adjnick = TNI_ADJNICK(dest->tn_ni, idx);
498 		if ((adj = trill_node_lookup(tip, adjnick)) == NULL)
499 			continue;
500 		if (memcmp(adj->tn_ni->tni_adjsnpa, srcaddr, ETHERADDRL) == 0) {
501 			trill_node_unref(tip, adj);
502 			break;
503 		}
504 		trill_node_unref(tip, adj);
505 	}
506 
507 	if (idx >= dest->tn_ni->tni_adjcount) {
508 		DTRACE_PROBE2(trill__recv__multidest__adjcheckfail,
509 		    trill_header_t *, trillhdr, trill_node_t *, dest);
510 		goto fail;
511 	}
512 
513 	/*
514 	 * Reverse path forwarding check. Check if the ingress RBridge
515 	 * that has forwarded the frame advertised the use of the
516 	 * distribution tree specified in the egress nick.
517 	 */
518 	if ((source = trill_node_lookup(tip, trillhdr->th_ingressnick)) == NULL)
519 		goto fail;
520 	for (idx = 0; idx < source->tn_ni->tni_dtrootcount; idx++) {
521 		if (TNI_DTROOTNICK(source->tn_ni, idx) ==
522 		    trillhdr->th_egressnick)
523 			break;
524 	}
525 
526 	if (idx >= source->tn_ni->tni_dtrootcount) {
527 		/*
528 		 * Allow receipt of forwarded frame with the highest
529 		 * tree root RBridge as the egress RBridge when the
530 		 * ingress RBridge has not advertised the use of any
531 		 * distribution trees.
532 		 */
533 		if (source->tn_ni->tni_dtrootcount != 0 ||
534 		    trillhdr->th_egressnick != treeroot) {
535 			DTRACE_PROBE3(
536 			    trill__recv__multidest__rpfcheckfail,
537 			    trill_header_t *, trillhdr, trill_node_t *,
538 			    source, trill_inst_t *, tip);
539 			goto fail;
540 		}
541 	}
542 
543 	/* Check hop count before doing any forwarding */
544 	if (trillhdr->th_hopcount == 0)
545 		goto fail;
546 
547 	/* Forward frame using the distribution tree specified by egress nick */
548 	DTRACE_PROBE2(trill__recv__multidest, trill_header_t *,
549 	    trillhdr, trill_node_t *, source);
550 	trill_node_unref(tip, source);
551 	trill_node_unref(tip, dest);
552 
553 	/* Tell forwarding not to free if we're the link forwarder. */
554 	trill_multidest_fwd(tip, mp, trillhdr->th_egressnick,
555 	    trillhdr->th_ingressnick, B_TRUE, srcaddr, inner_vlan,
556 	    B_FALSE);
557 
558 	/*
559 	 * Send de-capsulated frame locally if we are the link forwarder (also
560 	 * does bridge learning).
561 	 */
562 	mp->b_rptr += trillhdrlen;
563 	trill_recv_local(tsock, mp, trillhdr->th_ingressnick);
564 	KSPINCR(tks_recv);
565 	return;
566 
567 fail:
568 	DTRACE_PROBE2(trill__recv__multidest__fail, mblk_t *, mp,
569 	    trill_sock_t *, tsock);
570 	if (dest != NULL)
571 		trill_node_unref(tip, dest);
572 	if (source != NULL)
573 		trill_node_unref(tip, source);
574 	freemsg(mp);
575 	KSPINCR(tks_drops);
576 }
577 
578 static void
579 trill_stop_recv(trill_sock_t *tsock)
580 {
581 	mutex_enter(&tsock->ts_socklock);
582 stop_retry:
583 	if (tsock->ts_state == TS_UNBND || tsock->ts_link == NULL) {
584 		mutex_exit(&tsock->ts_socklock);
585 		return;
586 	}
587 
588 	/*
589 	 * If another thread is closing the socket then wait. Our callers
590 	 * expect us to return only after the socket is closed.
591 	 */
592 	if (tsock->ts_flags & TSF_CLOSEWAIT) {
593 		cv_wait(&tsock->ts_sockclosewait, &tsock->ts_socklock);
594 		goto stop_retry;
595 	}
596 
597 	/*
598 	 * Set state and flags to block new bind or close calls
599 	 * while we close the socket.
600 	 */
601 	tsock->ts_flags |= TSF_CLOSEWAIT;
602 
603 	/* Wait until all AF_TRILL socket transmit operations are done */
604 	while (tsock->ts_sockthreadcount > 0)
605 		cv_wait(&tsock->ts_sockthreadwait, &tsock->ts_socklock);
606 
607 	/*
608 	 * We are guaranteed to be the only thread closing on the
609 	 * socket while the TSF_CLOSEWAIT flag is set, all others cv_wait
610 	 * for us to finish.
611 	 */
612 	ASSERT(tsock->ts_link != NULL);
613 	if (tsock->ts_ksp != NULL)
614 		kstat_delete(tsock->ts_ksp);
615 
616 	/*
617 	 * Release lock before bridge_trill_lnunref to prevent deadlock
618 	 * between trill_ctrl_input thread waiting to acquire ts_socklock
619 	 * and bridge_trill_lnunref waiting for the trill thread to finish.
620 	 */
621 	mutex_exit(&tsock->ts_socklock);
622 
623 	/*
624 	 * Release TRILL link reference from Bridging. On return from
625 	 * bridge_trill_lnunref we can be sure there are no active TRILL data
626 	 * threads for this link.
627 	 */
628 	bridge_trill_lnunref(tsock->ts_link);
629 
630 	/* Set socket as unbound & wakeup threads waiting for socket to close */
631 	mutex_enter(&tsock->ts_socklock);
632 	ASSERT(tsock->ts_link != NULL);
633 	tsock->ts_link = NULL;
634 	tsock->ts_state = TS_UNBND;
635 	tsock->ts_flags &= ~TSF_CLOSEWAIT;
636 	cv_broadcast(&tsock->ts_sockclosewait);
637 	mutex_exit(&tsock->ts_socklock);
638 }
639 
640 static int
641 trill_start_recv(trill_sock_t *tsock, const struct sockaddr *sa, socklen_t len)
642 {
643 	struct sockaddr_dl *lladdr = (struct sockaddr_dl *)sa;
644 	datalink_id_t linkid;
645 	int err = 0;
646 
647 	if (len != sizeof (*lladdr))
648 		return (EINVAL);
649 
650 	mutex_enter(&tsock->ts_socklock);
651 	if (tsock->ts_tip == NULL || tsock->ts_state != TS_UNBND) {
652 		err = EINVAL;
653 		goto bind_error;
654 	}
655 
656 	if (tsock->ts_flags & TSF_CLOSEWAIT || tsock->ts_link != NULL) {
657 		err = EBUSY;
658 		goto bind_error;
659 	}
660 
661 	(void) memcpy(&(tsock->ts_lladdr), lladdr,
662 	    sizeof (struct sockaddr_dl));
663 	(void) memcpy(&linkid, tsock->ts_lladdr.sdl_data,
664 	    sizeof (datalink_id_t));
665 
666 	tsock->ts_link = bridge_trill_lnref(tsock->ts_tip->ti_binst,
667 	    linkid, tsock);
668 	if (tsock->ts_link == NULL) {
669 		err = EINVAL;
670 		goto bind_error;
671 	}
672 
673 	trill_kstats_init(tsock, tsock->ts_tip->ti_bridgename);
674 	tsock->ts_state = TS_IDLE;
675 
676 bind_error:
677 	mutex_exit(&tsock->ts_socklock);
678 	return (err);
679 }
680 
681 static int
682 trill_do_unbind(trill_sock_t *tsock)
683 {
684 	/* If a bind has not been done, we can't unbind. */
685 	if (tsock->ts_state != TS_IDLE)
686 		return (EINVAL);
687 
688 	trill_stop_recv(tsock);
689 	return (0);
690 }
691 
692 static void
693 trill_instance_unref(trill_inst_t *tip)
694 {
695 	rw_enter(&trill_inst_rwlock, RW_WRITER);
696 	rw_enter(&tip->ti_rwlock, RW_WRITER);
697 	if (atomic_dec_uint_nv(&tip->ti_refs) == 0) {
698 		list_remove(&trill_inst_list, tip);
699 		rw_exit(&tip->ti_rwlock);
700 		rw_exit(&trill_inst_rwlock);
701 		if (tip->ti_binst != NULL)
702 			bridge_trill_brunref(tip->ti_binst);
703 		list_destroy(&tip->ti_socklist);
704 		rw_destroy(&tip->ti_rwlock);
705 		kmem_free(tip, sizeof (*tip));
706 	} else {
707 		rw_exit(&tip->ti_rwlock);
708 		rw_exit(&trill_inst_rwlock);
709 	}
710 }
711 
712 /*
713  * This is called when the bridge module receives a TRILL-encapsulated packet
714  * on a given link or a packet identified as "TRILL control."  We must verify
715  * that it's for us (it almost certainly will be), and then either decapsulate
716  * (if it's to our nickname), forward (if it's to someone else), or send up one
717  * of the sockets (if it's control traffic).
718  *
719  * Sadly, on Ethernet, the control traffic is identified by Outer.MacDA, and
720  * not by TRILL header information.
721  */
722 static void
723 trill_recv_pkt_cb(void *lptr, bridge_link_t *blp, mac_resource_handle_t rsrc,
724     mblk_t *mp, mac_header_info_t *hdr_info)
725 {
726 	trill_sock_t *tsock = lptr;
727 
728 	_NOTE(ARGUNUSED(rsrc));
729 
730 	ASSERT(tsock->ts_tip != NULL);
731 	ASSERT(tsock->ts_link != NULL);
732 	ASSERT(!(tsock->ts_flags & TSF_SHUTDOWN));
733 
734 	/*
735 	 * Only receive packet if the source address is not multicast (which is
736 	 * bogus).
737 	 */
738 	if (hdr_info->mhi_saddr[0] & 1)
739 		goto discard;
740 
741 	/*
742 	 * Check if this is our own packet reflected back.  It should not be.
743 	 */
744 	if (bcmp(hdr_info->mhi_saddr, blp->bl_local_mac, ETHERADDRL) == 0)
745 		goto discard;
746 
747 	/* Only receive unicast packet if addressed to us */
748 	if (hdr_info->mhi_dsttype == MAC_ADDRTYPE_UNICAST &&
749 	    bcmp(hdr_info->mhi_daddr, blp->bl_local_mac, ETHERADDRL) != 0)
750 		goto discard;
751 
752 	if (hdr_info->mhi_bindsap == ETHERTYPE_TRILL) {
753 		/* TRILL data packets */
754 		trill_recv(tsock, mp, hdr_info->mhi_saddr);
755 	} else {
756 		/* Design constraint for cheap IS-IS/BPDU comparison */
757 		ASSERT(all_isis_rbridges[4] != bridge_group_address[4]);
758 		/* Send received control packet upstream */
759 		trill_ctrl_input(tsock, mp, hdr_info->mhi_saddr,
760 		    hdr_info->mhi_daddr[4] == all_isis_rbridges[4] ?
761 		    hdr_info->mhi_tci : TRILL_TCI_BPDU);
762 	}
763 
764 	return;
765 
766 discard:
767 	freemsg(mp);
768 	KSPINCR(tks_drops);
769 }
770 
771 /*
772  * This is called when the bridge module discovers that the destination address
773  * for a packet is not local -- it's through some remote node.  We must verify
774  * that the remote node isn't our nickname (it shouldn't be), add a TRILL
775  * header, and then use the IS-IS data to determine which link and which
776  * next-hop RBridge should be used for output.  We then transmit on that link.
777  *
778  * The egress_nick is RBRIDGE_NICKNAME_NONE for the "unknown destination" case.
779  */
780 static void
781 trill_encap_pkt_cb(void *lptr, bridge_link_t *blp, mac_header_info_t *hdr_info,
782     mblk_t *mp, uint16_t egress_nick)
783 {
784 	uint16_t ournick;
785 	uint16_t dtnick;
786 	trill_node_t *self = NULL;
787 	trill_sock_t *tsock = lptr;
788 	trill_inst_t *tip = tsock->ts_tip;
789 	int vlan = VLAN_ID_NONE;
790 
791 	_NOTE(ARGUNUSED(blp));
792 	ASSERT(hdr_info->mhi_bindsap != ETHERTYPE_TRILL);
793 
794 	/* egress_nick = RBRIDGE_NICKNAME_NONE is valid */
795 	if (egress_nick != RBRIDGE_NICKNAME_NONE && !VALID_NICK(egress_nick))
796 		goto discard;
797 
798 	/* Check if our own nick is valid before we do any forwarding */
799 	rw_enter(&tip->ti_rwlock, RW_READER);
800 	ournick = tip->ti_nick;
801 	dtnick = tip->ti_treeroot;
802 	rw_exit(&tip->ti_rwlock);
803 	if (!VALID_NICK(ournick))
804 		goto discard;
805 
806 	/*
807 	 * For Multi-Destination forwarding determine our choice of
808 	 * root distribution tree. If we didn't choose a distribution
809 	 * tree (dtroots_count=0) then we use the highest priority tree
810 	 * root (t_treeroot) else we drop the packet without forwarding.
811 	 */
812 	if (egress_nick == RBRIDGE_NICKNAME_NONE) {
813 		if ((self = trill_node_lookup(tip, ournick)) == NULL)
814 			goto discard;
815 
816 		/*
817 		 * Use the first DT configured for now. In future we
818 		 * should have DT selection code here.
819 		 */
820 		if (self->tn_ni->tni_dtrootcount > 0) {
821 			dtnick = TNI_DTROOTNICK(self->tn_ni, 0);
822 		}
823 
824 		trill_node_unref(tip, self);
825 		if (!VALID_NICK(dtnick)) {
826 			DTRACE_PROBE(trill__fwd__packet__nodtroot);
827 			goto discard;
828 		}
829 	}
830 
831 	/*
832 	 * Retrieve VLAN ID of the native frame used for VLAN
833 	 * pruning of multi-destination frames.
834 	 */
835 	if (hdr_info->mhi_istagged) {
836 		vlan = VLAN_ID(hdr_info->mhi_tci);
837 	}
838 
839 	DTRACE_PROBE2(trill__fwd__packet, mac_header_info_t *, hdr_info,
840 	    uint16_t, egress_nick);
841 	if (egress_nick == RBRIDGE_NICKNAME_NONE) {
842 		trill_multidest_fwd(tip, mp, dtnick,
843 		    ournick, B_FALSE, NULL, vlan, B_TRUE);
844 	} else {
845 		trill_dest_fwd(tip, mp, egress_nick, B_FALSE, B_FALSE,
846 		    RBRIDGE_NICKNAME_NONE);
847 	}
848 	KSPINCR(tks_encap);
849 	return;
850 
851 discard:
852 	freemsg(mp);
853 }
854 
855 /*
856  * This is called when the bridge module has completely torn down a bridge
857  * instance and all of the attached links.  We need to make the TRILL instance
858  * go away at this point.
859  */
860 static void
861 trill_br_dstr_cb(void *bptr, bridge_inst_t *bip)
862 {
863 	trill_inst_t *tip = bptr;
864 
865 	_NOTE(ARGUNUSED(bip));
866 	rw_enter(&tip->ti_rwlock, RW_WRITER);
867 	if (tip->ti_binst != NULL)
868 		bridge_trill_brunref(tip->ti_binst);
869 	tip->ti_binst = NULL;
870 	rw_exit(&tip->ti_rwlock);
871 }
872 
873 /*
874  * This is called when the bridge module is tearing down a link, but before the
875  * actual tear-down starts.  When this function returns, we must make sure that
876  * we will not initiate any new transmits on this link.
877  */
878 static void
879 trill_ln_dstr_cb(void *lptr, bridge_link_t *blp)
880 {
881 	trill_sock_t *tsock = lptr;
882 
883 	_NOTE(ARGUNUSED(blp));
884 	trill_stop_recv(tsock);
885 }
886 
887 static void
888 trill_init(void)
889 {
890 	list_create(&trill_inst_list, sizeof (trill_inst_t),
891 	    offsetof(trill_inst_t, ti_instnode));
892 	rw_init(&trill_inst_rwlock, NULL, RW_DRIVER, NULL);
893 	bridge_trill_register_cb(trill_recv_pkt_cb, trill_encap_pkt_cb,
894 	    trill_br_dstr_cb, trill_ln_dstr_cb);
895 }
896 
897 static void
898 trill_fini(void)
899 {
900 	bridge_trill_register_cb(NULL, NULL, NULL, NULL);
901 	rw_destroy(&trill_inst_rwlock);
902 	list_destroy(&trill_inst_list);
903 }
904 
905 /* Loadable module configuration entry points */
906 int
907 _init(void)
908 {
909 	int rc;
910 
911 	trill_init();
912 	if ((rc = mod_install(&ml)) != 0)
913 		trill_fini();
914 	return (rc);
915 }
916 
917 int
918 _info(struct modinfo *modinfop)
919 {
920 	return (mod_info(&ml, modinfop));
921 }
922 
923 int
924 _fini(void)
925 {
926 	int rc;
927 
928 	rw_enter(&trill_inst_rwlock, RW_READER);
929 	rc = list_is_empty(&trill_inst_list) ? 0 : EBUSY;
930 	rw_exit(&trill_inst_rwlock);
931 	if (rc == 0 && ((rc = mod_remove(&ml)) == 0))
932 		trill_fini();
933 	return (rc);
934 }
935 
936 static void
937 trill_kstats_init(trill_sock_t *tsock, const char *bname)
938 {
939 	int i;
940 	char kstatname[KSTAT_STRLEN];
941 	kstat_named_t  *knt;
942 	static const char *sock_kstats_list[] = { TRILL_KSSOCK_NAMES };
943 	char link_name[MAXNAMELEN];
944 	int num;
945 	int err;
946 
947 	bzero(link_name, sizeof (link_name));
948 	if ((err = dls_mgmt_get_linkinfo(tsock->ts_link->bl_linkid, link_name,
949 	    NULL, NULL, NULL)) != 0) {
950 		cmn_err(CE_WARN, "%s: trill_kstats_init: error %d retrieving"
951 		    " linkinfo for linkid:%d", "trill", err,
952 		    tsock->ts_link->bl_linkid);
953 		return;
954 	}
955 
956 	bzero(kstatname, sizeof (kstatname));
957 	(void) snprintf(kstatname, sizeof (kstatname), "%s-%s",
958 	    bname, link_name);
959 
960 	num = sizeof (sock_kstats_list) / sizeof (*sock_kstats_list);
961 	for (i = 0; i < num; i++) {
962 		knt = (kstat_named_t *)&(tsock->ts_kstats);
963 		kstat_named_init(&knt[i], sock_kstats_list[i],
964 		    KSTAT_DATA_UINT64);
965 	}
966 
967 	tsock->ts_ksp = kstat_create_zone("trill", 0, kstatname, "sock",
968 	    KSTAT_TYPE_NAMED, num, KSTAT_FLAG_VIRTUAL, GLOBAL_ZONEID);
969 	if (tsock->ts_ksp != NULL) {
970 		tsock->ts_ksp->ks_data = &tsock->ts_kstats;
971 		kstat_install(tsock->ts_ksp);
972 	}
973 }
974 
975 static trill_sock_t *
976 trill_do_open(int flags)
977 {
978 	trill_sock_t *tsock;
979 	int kmflag = ((flags & SOCKET_NOSLEEP)) ? KM_NOSLEEP:KM_SLEEP;
980 
981 	tsock = kmem_zalloc(sizeof (trill_sock_t), kmflag);
982 	if (tsock != NULL) {
983 		tsock->ts_state = TS_UNBND;
984 		tsock->ts_refs++;
985 		mutex_init(&tsock->ts_socklock, NULL, MUTEX_DRIVER, NULL);
986 		cv_init(&tsock->ts_sockthreadwait, NULL, CV_DRIVER, NULL);
987 		cv_init(&tsock->ts_sockclosewait, NULL, CV_DRIVER, NULL);
988 	}
989 	return (tsock);
990 }
991 
992 static int
993 trill_find_bridge(trill_sock_t *tsock, const char *bname, boolean_t can_create)
994 {
995 	trill_inst_t *tip, *newtip = NULL;
996 
997 	/* Allocate some memory (speculatively) before taking locks */
998 	if (can_create)
999 		newtip = kmem_zalloc(sizeof (*tip), KM_NOSLEEP);
1000 
1001 	rw_enter(&trill_inst_rwlock, RW_WRITER);
1002 	for (tip = list_head(&trill_inst_list); tip != NULL;
1003 	    tip = list_next(&trill_inst_list, tip)) {
1004 		if (strcmp(tip->ti_bridgename, bname) == 0)
1005 			break;
1006 	}
1007 	if (tip == NULL) {
1008 		if (!can_create || newtip == NULL) {
1009 			rw_exit(&trill_inst_rwlock);
1010 			return (can_create ? ENOMEM : ENOENT);
1011 		}
1012 
1013 		tip = newtip;
1014 		newtip = NULL;
1015 		(void) strcpy(tip->ti_bridgename, bname);
1016 
1017 		/* Register TRILL instance with bridging */
1018 		tip->ti_binst = bridge_trill_brref(bname, tip);
1019 		if (tip->ti_binst == NULL) {
1020 			rw_exit(&trill_inst_rwlock);
1021 			kmem_free(tip, sizeof (*tip));
1022 			return (ENOENT);
1023 		}
1024 
1025 		rw_init(&tip->ti_rwlock, NULL, RW_DRIVER, NULL);
1026 		list_create(&tip->ti_socklist, sizeof (trill_sock_t),
1027 		    offsetof(trill_sock_t, ts_socklistnode));
1028 		list_insert_tail(&trill_inst_list, tip);
1029 	}
1030 	atomic_inc_uint(&tip->ti_refs);
1031 	rw_exit(&trill_inst_rwlock);
1032 
1033 	/* If we didn't need the preallocated memory, then discard now. */
1034 	if (newtip != NULL)
1035 		kmem_free(newtip, sizeof (*newtip));
1036 
1037 	rw_enter(&tip->ti_rwlock, RW_WRITER);
1038 	list_insert_tail(&(tip->ti_socklist), tsock);
1039 	tsock->ts_tip = tip;
1040 	rw_exit(&tip->ti_rwlock);
1041 	return (0);
1042 }
1043 
1044 static void
1045 trill_clear_bridge(trill_sock_t *tsock)
1046 {
1047 	trill_inst_t *tip;
1048 
1049 	if ((tip = tsock->ts_tip) == NULL)
1050 		return;
1051 	rw_enter(&tip->ti_rwlock, RW_WRITER);
1052 	list_remove(&tip->ti_socklist, tsock);
1053 	if (list_is_empty(&tip->ti_socklist))
1054 		trill_del_all(tip, B_TRUE);
1055 	rw_exit(&tip->ti_rwlock);
1056 }
1057 
1058 static void
1059 trill_sock_unref(trill_sock_t *tsock)
1060 {
1061 	if (atomic_dec_uint_nv(&tsock->ts_refs) == 0) {
1062 		mutex_destroy(&tsock->ts_socklock);
1063 		cv_destroy(&tsock->ts_sockthreadwait);
1064 		cv_destroy(&tsock->ts_sockclosewait);
1065 		kmem_free(tsock, sizeof (trill_sock_t));
1066 	}
1067 }
1068 
1069 static void
1070 trill_do_close(trill_sock_t *tsock)
1071 {
1072 	trill_inst_t *tip;
1073 
1074 	tip = tsock->ts_tip;
1075 	trill_stop_recv(tsock);
1076 	/* Remove socket from TRILL instance socket list */
1077 	trill_clear_bridge(tsock);
1078 	tsock->ts_flags |= TSF_SHUTDOWN;
1079 	trill_sock_unref(tsock);
1080 	if (tip != NULL)
1081 		trill_instance_unref(tip);
1082 }
1083 
1084 static void
1085 trill_del_all(trill_inst_t *tip, boolean_t lockheld)
1086 {
1087 	int i;
1088 
1089 	if (!lockheld)
1090 		rw_enter(&tip->ti_rwlock, RW_WRITER);
1091 	for (i = RBRIDGE_NICKNAME_MIN; i < RBRIDGE_NICKNAME_MAX; i++) {
1092 		if (tip->ti_nodes[i] != NULL)
1093 			(void) trill_del_nick(tip, i, B_TRUE);
1094 	}
1095 	if (!lockheld)
1096 		rw_exit(&tip->ti_rwlock);
1097 }
1098 
1099 static void
1100 trill_node_free(trill_node_t *nick_entry)
1101 {
1102 	trill_nickinfo_t *tni;
1103 
1104 	tni = nick_entry->tn_ni;
1105 	kmem_free(tni, TNI_TOTALSIZE(tni));
1106 	kmem_free(nick_entry, sizeof (trill_node_t));
1107 }
1108 
1109 static void
1110 trill_node_unref(trill_inst_t *tip, trill_node_t *tnp)
1111 {
1112 	if (atomic_dec_uint_nv(&tnp->tn_refs) == 0) {
1113 		if (tnp->tn_tsp != NULL)
1114 			trill_sock_unref(tnp->tn_tsp);
1115 		trill_node_free(tnp);
1116 		(void) atomic_dec_uint_nv(&tip->ti_nodecount);
1117 	}
1118 }
1119 
1120 static trill_node_t *
1121 trill_node_lookup(trill_inst_t *tip, uint16_t nick)
1122 {
1123 	trill_node_t *nick_entry;
1124 
1125 	if (!VALID_NICK(nick))
1126 		return (NULL);
1127 	rw_enter(&tip->ti_rwlock, RW_READER);
1128 	nick_entry = tip->ti_nodes[nick];
1129 	if (nick_entry != NULL) {
1130 		atomic_inc_uint(&nick_entry->tn_refs);
1131 	}
1132 	rw_exit(&tip->ti_rwlock);
1133 	return (nick_entry);
1134 }
1135 
1136 static int
1137 trill_del_nick(trill_inst_t *tip, uint16_t nick, boolean_t lockheld)
1138 {
1139 	trill_node_t *nick_entry;
1140 	int rc = ENOENT;
1141 
1142 	if (!lockheld)
1143 		rw_enter(&tip->ti_rwlock, RW_WRITER);
1144 	if (VALID_NICK(nick)) {
1145 		nick_entry = tip->ti_nodes[nick];
1146 		if (nick_entry != NULL) {
1147 			trill_node_unref(tip, nick_entry);
1148 			tip->ti_nodes[nick] = NULL;
1149 			rc = 0;
1150 		}
1151 	}
1152 	if (!lockheld)
1153 		rw_exit(&tip->ti_rwlock);
1154 	return (rc);
1155 }
1156 
1157 static int
1158 trill_add_nick(trill_inst_t *tip, void *arg, boolean_t self, int mode)
1159 {
1160 	uint16_t nick;
1161 	int size;
1162 	trill_node_t *tnode;
1163 	trill_nickinfo_t tnihdr;
1164 
1165 	/* First make sure we have at least the header available */
1166 	if (ddi_copyin(arg, &tnihdr, sizeof (trill_nickinfo_t), mode) != 0)
1167 		return (EFAULT);
1168 
1169 	nick = tnihdr.tni_nick;
1170 	if (!VALID_NICK(nick)) {
1171 		DTRACE_PROBE1(trill__add__nick__bad, trill_nickinfo_t *,
1172 		    &tnihdr);
1173 		return (EINVAL);
1174 	}
1175 
1176 	size = TNI_TOTALSIZE(&tnihdr);
1177 	if (size > TNI_MAXSIZE)
1178 		return (EINVAL);
1179 	tnode = kmem_zalloc(sizeof (trill_node_t), KM_SLEEP);
1180 	tnode->tn_ni = kmem_zalloc(size, KM_SLEEP);
1181 	if (ddi_copyin(arg, tnode->tn_ni, size, mode) != 0) {
1182 		kmem_free(tnode->tn_ni, size);
1183 		kmem_free(tnode, sizeof (trill_node_t));
1184 		return (EFAULT);
1185 	}
1186 
1187 	tnode->tn_refs++;
1188 	rw_enter(&tip->ti_rwlock, RW_WRITER);
1189 	if (tip->ti_nodes[nick] != NULL)
1190 		(void) trill_del_nick(tip, nick, B_TRUE);
1191 
1192 	if (self) {
1193 		tip->ti_nick = nick;
1194 	} else {
1195 		tnode->tn_tsp = find_trill_link(tip,
1196 		    tnode->tn_ni->tni_linkid);
1197 	}
1198 	DTRACE_PROBE2(trill__add__nick, trill_node_t *, tnode,
1199 	    uint16_t, nick);
1200 	tip->ti_nodes[nick] = tnode;
1201 	tip->ti_nodecount++;
1202 	rw_exit(&tip->ti_rwlock);
1203 	return (0);
1204 }
1205 
1206 static int
1207 trill_do_ioctl(trill_sock_t *tsock, int cmd, void *arg, int mode)
1208 {
1209 	int error = 0;
1210 	trill_inst_t *tip = tsock->ts_tip;
1211 
1212 	switch (cmd) {
1213 	case TRILL_DESIGVLAN: {
1214 		uint16_t desigvlan;
1215 
1216 		if (ddi_copyin(arg, &desigvlan, sizeof (desigvlan), mode) != 0)
1217 			return (EFAULT);
1218 		tsock->ts_desigvlan = desigvlan;
1219 		break;
1220 	}
1221 	case TRILL_VLANFWDER: {
1222 		uint8_t vlans[TRILL_VLANS_ARRSIZE];
1223 
1224 		if (tsock->ts_link == NULL)
1225 			return (EINVAL);
1226 		if ((ddi_copyin(arg, vlans, sizeof (vlans), mode)) != 0)
1227 			return (EFAULT);
1228 		bridge_trill_setvlans(tsock->ts_link, vlans);
1229 		break;
1230 	}
1231 	case TRILL_SETNICK:
1232 		if (tip == NULL)
1233 			return (EINVAL);
1234 		error = trill_add_nick(tip, arg, B_TRUE, mode);
1235 		break;
1236 
1237 	case TRILL_GETNICK:
1238 		if (tip == NULL)
1239 			return (EINVAL);
1240 		rw_enter(&tip->ti_rwlock, RW_READER);
1241 		if (ddi_copyout(&tip->ti_nick, arg, sizeof (tip->ti_nick),
1242 		    mode) != 0)
1243 			error = EFAULT;
1244 		rw_exit(&tip->ti_rwlock);
1245 		break;
1246 
1247 	case TRILL_ADDNICK:
1248 		if (tip == NULL)
1249 			break;
1250 		error = trill_add_nick(tip, arg, B_FALSE, mode);
1251 		break;
1252 
1253 	case TRILL_DELNICK: {
1254 		uint16_t delnick;
1255 
1256 		if (tip == NULL)
1257 			break;
1258 		if (ddi_copyin(arg, &delnick, sizeof (delnick), mode) != 0)
1259 			return (EFAULT);
1260 		error = trill_del_nick(tip, delnick, B_FALSE);
1261 		break;
1262 	}
1263 	case TRILL_DELALL:
1264 		if (tip == NULL)
1265 			break;
1266 		trill_del_all(tip, B_FALSE);
1267 		break;
1268 
1269 	case TRILL_TREEROOT: {
1270 		uint16_t treeroot;
1271 
1272 		if (tip == NULL)
1273 			break;
1274 		if (ddi_copyin(arg, &treeroot, sizeof (treeroot), mode) != 0)
1275 			return (EFAULT);
1276 		if (!VALID_NICK(treeroot))
1277 			return (EINVAL);
1278 		rw_enter(&tip->ti_rwlock, RW_WRITER);
1279 		tip->ti_treeroot = treeroot;
1280 		rw_exit(&tip->ti_rwlock);
1281 		break;
1282 	}
1283 	case TRILL_HWADDR:
1284 		if (tsock->ts_link == NULL)
1285 			break;
1286 		if (ddi_copyout(tsock->ts_link->bl_local_mac, arg, ETHERADDRL,
1287 		    mode) != 0)
1288 			return (EFAULT);
1289 		break;
1290 
1291 	case TRILL_NEWBRIDGE: {
1292 		char bname[MAXLINKNAMELEN];
1293 
1294 		if (tsock->ts_state != TS_UNBND)
1295 			return (ENOTSUP);
1296 		/* ts_tip can only be set once */
1297 		if (tip != NULL)
1298 			return (EEXIST);
1299 		if (ddi_copyin(arg, bname, sizeof (bname), mode) != 0)
1300 			return (EFAULT);
1301 		bname[MAXLINKNAMELEN-1] = '\0';
1302 		error = trill_find_bridge(tsock, bname, B_TRUE);
1303 		break;
1304 	}
1305 
1306 	case TRILL_GETBRIDGE: {
1307 		char bname[MAXLINKNAMELEN];
1308 
1309 		/* ts_tip can only be set once */
1310 		if (tip != NULL)
1311 			return (EEXIST);
1312 		if (ddi_copyin(arg, bname, sizeof (bname), mode) != 0)
1313 			return (EFAULT);
1314 		bname[MAXLINKNAMELEN - 1] = '\0';
1315 		error = trill_find_bridge(tsock, bname, B_FALSE);
1316 		break;
1317 	}
1318 
1319 	case TRILL_LISTNICK: {
1320 		trill_listnick_t tln;
1321 		trill_node_t *tnp;
1322 		trill_nickinfo_t *tnip;
1323 		uint16_t nick;
1324 
1325 		if (tip == NULL)
1326 			return (EINVAL);
1327 		if (ddi_copyin(arg, &tln, sizeof (tln), mode) != 0)
1328 			return (EFAULT);
1329 		nick = tln.tln_nick;
1330 		if (nick >= RBRIDGE_NICKNAME_MAX) {
1331 			error = EINVAL;
1332 			break;
1333 		}
1334 		rw_enter(&tip->ti_rwlock, RW_READER);
1335 		while (++nick < RBRIDGE_NICKNAME_MAX) {
1336 			if ((tnp = tip->ti_nodes[nick]) != NULL) {
1337 				tnip = tnp->tn_ni;
1338 				ASSERT(nick == tnip->tni_nick);
1339 				tln.tln_nick = nick;
1340 				bcopy(tnip->tni_adjsnpa, tln.tln_nexthop,
1341 				    ETHERADDRL);
1342 				tln.tln_ours = nick == tip->ti_nick;
1343 				if (tln.tln_ours || tnp->tn_tsp == NULL) {
1344 					tln.tln_linkid =
1345 					    DATALINK_INVALID_LINKID;
1346 				} else {
1347 					tln.tln_linkid =
1348 					    tnp->tn_tsp->ts_link->bl_linkid;
1349 				}
1350 				break;
1351 			}
1352 		}
1353 		rw_exit(&tip->ti_rwlock);
1354 		if (nick >= RBRIDGE_NICKNAME_MAX)
1355 			bzero(&tln, sizeof (tln));
1356 		if (ddi_copyout(&tln, arg, sizeof (tln), mode) != 0)
1357 			return (EFAULT);
1358 		break;
1359 	}
1360 
1361 	/*
1362 	 * Port flush: this is used when we lose AF on a port.  We must discard
1363 	 * all regular bridge forwarding entries on this port with the
1364 	 * indicated VLAN.
1365 	 */
1366 	case TRILL_PORTFLUSH: {
1367 		uint16_t vlan = (uint16_t)(uintptr_t)arg;
1368 
1369 		if (tsock->ts_link == NULL)
1370 			return (EINVAL);
1371 		bridge_trill_flush(tsock->ts_link, vlan, B_FALSE);
1372 		break;
1373 	}
1374 
1375 	/*
1376 	 * Nick flush: this is used when we lose AF on a port.  We must discard
1377 	 * all bridge TRILL forwarding entries on this port with the indicated
1378 	 * VLAN.
1379 	 */
1380 	case TRILL_NICKFLUSH: {
1381 		uint16_t vlan = (uint16_t)(uintptr_t)arg;
1382 
1383 		if (tsock->ts_link == NULL)
1384 			return (EINVAL);
1385 		bridge_trill_flush(tsock->ts_link, vlan, B_TRUE);
1386 		break;
1387 	}
1388 
1389 	case TRILL_GETMTU:
1390 		if (tsock->ts_link == NULL)
1391 			break;
1392 		if (ddi_copyout(&tsock->ts_link->bl_maxsdu, arg,
1393 		    sizeof (uint_t), mode) != 0)
1394 			return (EFAULT);
1395 		break;
1396 
1397 	default:
1398 		error = ENOTSUP;
1399 		break;
1400 	}
1401 
1402 	return (error);
1403 }
1404 
1405 /*
1406  * Sends received packet back upstream on the TRILL socket.
1407  * Consumes passed mblk_t.
1408  */
1409 static void
1410 trill_ctrl_input(trill_sock_t *tsock, mblk_t *mp, const uint8_t *saddr,
1411     uint16_t tci)
1412 {
1413 	int udi_size;
1414 	mblk_t *mp1;
1415 	struct T_unitdata_ind *tudi;
1416 	struct sockaddr_dl *sdl;
1417 	char *lladdr;
1418 	int error;
1419 
1420 	ASSERT(!(tsock->ts_flags & TSF_SHUTDOWN));
1421 	if (tsock->ts_flow_ctrld) {
1422 		freemsg(mp);
1423 		KSPINCR(tks_drops);
1424 		return;
1425 	}
1426 
1427 	udi_size =  sizeof (struct T_unitdata_ind) +
1428 	    sizeof (struct sockaddr_dl);
1429 	mp1 = allocb(udi_size, BPRI_MED);
1430 	if (mp1 == NULL) {
1431 		freemsg(mp);
1432 		KSPINCR(tks_drops);
1433 		return;
1434 	}
1435 
1436 	mp1->b_cont = mp;
1437 	mp = mp1;
1438 	mp->b_datap->db_type = M_PROTO;
1439 	/* LINTED: alignment */
1440 	tudi = (struct T_unitdata_ind *)mp->b_rptr;
1441 	mp->b_wptr = (uchar_t *)tudi + udi_size;
1442 
1443 	tudi->PRIM_type = T_UNITDATA_IND;
1444 	tudi->SRC_length = sizeof (struct sockaddr_dl);
1445 	tudi->SRC_offset = sizeof (struct T_unitdata_ind);
1446 	tudi->OPT_length = 0;
1447 	tudi->OPT_offset = sizeof (struct T_unitdata_ind) +
1448 	    sizeof (struct sockaddr_dl);
1449 
1450 	/* Information of the link on which packet was received. */
1451 	sdl = (struct sockaddr_dl *)&tudi[1];
1452 	(void) memset(sdl, 0, sizeof (struct sockaddr_dl));
1453 	sdl->sdl_family = AF_TRILL;
1454 
1455 	/* LINTED: alignment */
1456 	*(datalink_id_t *)sdl->sdl_data = tsock->ts_link->bl_linkid;
1457 	sdl->sdl_nlen = sizeof (tsock->ts_link->bl_linkid);
1458 
1459 	lladdr = LLADDR(sdl);
1460 	(void) memcpy(lladdr, saddr, ETHERADDRL);
1461 	lladdr += ETHERADDRL;
1462 	sdl->sdl_alen = ETHERADDRL;
1463 
1464 	/* LINTED: alignment */
1465 	*(uint16_t *)lladdr = tci;
1466 	sdl->sdl_slen = sizeof (uint16_t);
1467 
1468 	DTRACE_PROBE2(trill__ctrl__input, trill_sock_t *, tsock, mblk_t *, mp);
1469 	(*tsock->ts_conn_upcalls->su_recv)(tsock->ts_conn_upper_handle,
1470 	    mp, msgdsize(mp), 0, &error, NULL);
1471 
1472 	if (error == ENOSPC) {
1473 		mutex_enter(&tsock->ts_socklock);
1474 		(*tsock->ts_conn_upcalls->su_recv)(tsock->ts_conn_upper_handle,
1475 		    NULL, 0, 0, &error, NULL);
1476 		if (error == ENOSPC)
1477 			tsock->ts_flow_ctrld = B_TRUE;
1478 		mutex_exit(&tsock->ts_socklock);
1479 		KSPINCR(tks_drops);
1480 	} else if (error != 0) {
1481 		KSPINCR(tks_drops);
1482 	} else {
1483 		KSPINCR(tks_recv);
1484 	}
1485 
1486 	DTRACE_PROBE2(trill__ctrl__input__done, trill_sock_t *,
1487 	    tsock, int, error);
1488 }
1489 
1490 /* ARGSUSED */
1491 static void
1492 trill_activate(sock_lower_handle_t proto_handle,
1493     sock_upper_handle_t sock_handle, sock_upcalls_t *sock_upcalls,
1494     int flags, cred_t *cr)
1495 {
1496 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1497 	struct sock_proto_props sopp;
1498 
1499 	tsock->ts_conn_upcalls = sock_upcalls;
1500 	tsock->ts_conn_upper_handle = sock_handle;
1501 
1502 	sopp.sopp_flags = SOCKOPT_WROFF | SOCKOPT_RCVHIWAT |
1503 	    SOCKOPT_RCVLOWAT | SOCKOPT_MAXADDRLEN | SOCKOPT_MAXPSZ |
1504 	    SOCKOPT_MAXBLK | SOCKOPT_MINPSZ;
1505 	sopp.sopp_wroff = 0;
1506 	sopp.sopp_rxhiwat = SOCKET_RECVHIWATER;
1507 	sopp.sopp_rxlowat = SOCKET_RECVLOWATER;
1508 	sopp.sopp_maxaddrlen = sizeof (struct sockaddr_dl);
1509 	sopp.sopp_maxpsz = INFPSZ;
1510 	sopp.sopp_maxblk = INFPSZ;
1511 	sopp.sopp_minpsz = 0;
1512 	(*tsock->ts_conn_upcalls->su_set_proto_props)(
1513 	    tsock->ts_conn_upper_handle, &sopp);
1514 }
1515 
1516 /* ARGSUSED */
1517 static int
1518 trill_close(sock_lower_handle_t proto_handle, int flags, cred_t *cr)
1519 {
1520 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1521 
1522 	trill_do_close(tsock);
1523 	return (0);
1524 }
1525 
1526 /* ARGSUSED */
1527 static int
1528 trill_bind(sock_lower_handle_t proto_handle, struct sockaddr *sa,
1529     socklen_t len, cred_t *cr)
1530 {
1531 	int error;
1532 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1533 
1534 	if (sa == NULL)
1535 		error = trill_do_unbind(tsock);
1536 	else
1537 		error = trill_start_recv(tsock, sa, len);
1538 
1539 	return (error);
1540 }
1541 
1542 /* ARGSUSED */
1543 static int
1544 trill_send(sock_lower_handle_t proto_handle, mblk_t *mp, struct nmsghdr *msg,
1545     cred_t *cr)
1546 {
1547 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1548 	struct sockaddr_dl *laddr;
1549 	uint16_t tci;
1550 
1551 	ASSERT(DB_TYPE(mp) == M_DATA);
1552 	ASSERT(!(tsock->ts_flags & TSF_SHUTDOWN));
1553 
1554 	if (msg->msg_name == NULL || msg->msg_namelen != sizeof (*laddr))
1555 		goto eproto;
1556 
1557 	/*
1558 	 * The name is a datalink_id_t, the address is an Ethernet address, and
1559 	 * the selector value is the VLAN ID.
1560 	 */
1561 	laddr = (struct sockaddr_dl *)msg->msg_name;
1562 	if (laddr->sdl_nlen != sizeof (datalink_id_t) ||
1563 	    laddr->sdl_alen != ETHERADDRL ||
1564 	    (laddr->sdl_slen != sizeof (tci) && laddr->sdl_slen != 0))
1565 		goto eproto;
1566 
1567 	mutex_enter(&tsock->ts_socklock);
1568 	if (tsock->ts_state != TS_IDLE || tsock->ts_link == NULL) {
1569 		mutex_exit(&tsock->ts_socklock);
1570 		goto eproto;
1571 	}
1572 	atomic_inc_uint(&tsock->ts_sockthreadcount);
1573 	mutex_exit(&tsock->ts_socklock);
1574 
1575 	/*
1576 	 * Safe to dereference VLAN now, as we've checked the user's specified
1577 	 * values, and alignment is now guaranteed.
1578 	 */
1579 	if (laddr->sdl_slen == 0) {
1580 		tci = TRILL_NO_TCI;
1581 	} else {
1582 		/* LINTED: alignment */
1583 		tci = *(uint16_t *)(LLADDR(laddr) + ETHERADDRL);
1584 	}
1585 
1586 	mp = create_trill_header(tsock, mp, (const uchar_t *)LLADDR(laddr),
1587 	    B_TRUE, B_FALSE, tci, msgdsize(mp));
1588 	if (mp != NULL) {
1589 		mp = bridge_trill_output(tsock->ts_link, mp);
1590 		if (mp == NULL) {
1591 			KSPINCR(tks_sent);
1592 		} else {
1593 			freemsg(mp);
1594 			KSPINCR(tks_drops);
1595 		}
1596 	}
1597 
1598 	/* Wake up any threads blocking on us */
1599 	if (atomic_dec_uint_nv(&tsock->ts_sockthreadcount) == 0)
1600 		cv_broadcast(&tsock->ts_sockthreadwait);
1601 	return (0);
1602 
1603 eproto:
1604 	freemsg(mp);
1605 	KSPINCR(tks_drops);
1606 	return (EPROTO);
1607 }
1608 
1609 /* ARGSUSED */
1610 static int
1611 trill_ioctl(sock_lower_handle_t proto_handle, int cmd, intptr_t arg,
1612     int mode, int32_t *rvalp, cred_t *cr)
1613 {
1614 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1615 	int rc;
1616 
1617 	switch (cmd) {
1618 	/* List of unprivileged TRILL ioctls */
1619 	case TRILL_GETNICK:
1620 	case TRILL_GETBRIDGE:
1621 	case TRILL_LISTNICK:
1622 		break;
1623 	default:
1624 		if (secpolicy_dl_config(cr) != 0)
1625 			return (EPERM);
1626 		break;
1627 	}
1628 
1629 	/* Lock ensures socket state is unchanged during ioctl handling */
1630 	mutex_enter(&tsock->ts_socklock);
1631 	rc = trill_do_ioctl(tsock, cmd, (void *)arg, mode);
1632 	mutex_exit(&tsock->ts_socklock);
1633 	return (rc);
1634 }
1635 
1636 static void
1637 trill_clr_flowctrl(sock_lower_handle_t proto_handle)
1638 {
1639 	trill_sock_t *tsock = (trill_sock_t *)proto_handle;
1640 
1641 	mutex_enter(&tsock->ts_socklock);
1642 	tsock->ts_flow_ctrld = B_FALSE;
1643 	mutex_exit(&tsock->ts_socklock);
1644 }
1645 
1646 static sock_downcalls_t sock_trill_downcalls = {
1647 	trill_activate,			/* sd_activate */
1648 	sock_accept_notsupp,		/* sd_accept */
1649 	trill_bind,			/* sd_bind */
1650 	sock_listen_notsupp,		/* sd_listen */
1651 	sock_connect_notsupp,		/* sd_connect */
1652 	sock_getpeername_notsupp,	/* sd_getpeername */
1653 	sock_getsockname_notsupp,	/* sd_getsockname */
1654 	sock_getsockopt_notsupp,	/* sd_getsockopt */
1655 	sock_setsockopt_notsupp,	/* sd_setsockopt */
1656 	trill_send,			/* sd_send */
1657 	NULL,				/* sd_send_uio */
1658 	NULL,				/* sd_recv_uio */
1659 	NULL,				/* sd_poll */
1660 	sock_shutdown_notsupp,		/* sd_shutdown */
1661 	trill_clr_flowctrl,		/* sd_setflowctrl */
1662 	trill_ioctl,			/* sd_ioctl */
1663 	trill_close			/* sd_close */
1664 };
1665 
1666 /* ARGSUSED */
1667 static sock_lower_handle_t
1668 trill_create(int family, int type, int proto, sock_downcalls_t **sock_downcalls,
1669     uint_t *smodep, int *errorp, int flags, cred_t *credp)
1670 {
1671 	trill_sock_t *tsock;
1672 
1673 	if (family != AF_TRILL || type != SOCK_DGRAM || proto != 0) {
1674 		*errorp = EPROTONOSUPPORT;
1675 		return (NULL);
1676 	}
1677 
1678 	*sock_downcalls = &sock_trill_downcalls;
1679 	*smodep = SM_ATOMIC;
1680 	tsock = trill_do_open(flags);
1681 	*errorp = (tsock != NULL) ? 0:ENOMEM;
1682 	return ((sock_lower_handle_t)tsock);
1683 }
1684