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