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                 atomic_dec_uint(&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 }