sys/net/bridge.c

   1 /*-
   2  * Copyright (c) 1998-2002 Luigi Rizzo
   3  *
   4  * Work partly supported by: Cisco Systems, Inc. - NSITE lab, RTP, NC
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 /*
  31  * This code implements bridging in FreeBSD. It only acts on ethernet
  32  * interfaces, including VLANs (others are still usable for routing).
  33  * A FreeBSD host can implement multiple logical bridges, called
  34  * "clusters". Each cluster is made of a set of interfaces, and
  35  * identified by a "cluster-id" which is a number in the range 1..2^16-1.
  36  *
  37  * Bridging is enabled by the sysctl variable
  38  *      net.link.ether.bridge.enable
  39  * the grouping of interfaces into clusters is done with
  40  *      net.link.ether.bridge.config
  41  * containing a list of interfaces each optionally followed by
  42  * a colon and the cluster it belongs to (1 is the default).
  43  * Separators can be spaces, commas or tabs, e.g.
  44  *      net.link.ether.bridge.config="fxp0:2 fxp1:2 dc0 dc1:1"
  45  * Optionally bridged packets can be passed through the firewall,
  46  * this is controlled by the variable
  47  *      net.link.ether.bridge.ipfw
  48  *
  49  * For each cluster there is a descriptor (cluster_softc) storing
  50  * the following data structures:
  51  * - a hash table with the MAC address and destination interface for each
  52  *   known node. The table is indexed using a hash of the source address.
  53  * - an array with the MAC addresses of the interfaces used in the cluster.
  54  *
  55  * Input packets are tapped near the beginning of ether_input(), and
  56  * analysed by bridge_in(). Depending on the result, the packet
  57  * can be forwarded to one or more output interfaces using bdg_forward(),
  58  * and/or sent to the upper layer (e.g. in case of multicast).
  59  *
  60  * Output packets are intercepted near the end of ether_output().
  61  * The correct destination is selected by bridge_dst_lookup(),
  62  * and then forwarding is done by bdg_forward().
  63  *
  64  * The arp code is also modified to let a machine answer to requests
  65  * irrespective of the port the request came from.
  66  *
  67  * In case of loops in the bridging topology, the bridge detects this
  68  * event and temporarily mutes output bridging on one of the ports.
  69  * Periodically, interfaces are unmuted by bdg_timeout().
  70  * Muting is only implemented as a safety measure, and also as
  71  * a mechanism to support a user-space implementation of the spanning
  72  * tree algorithm.
  73  *
  74  * To build a bridging kernel, use the following option
  75  *    option BRIDGE
  76  * and then at runtime set the sysctl variable to enable bridging.
  77  *
  78  * Only one interface per cluster is supposed to have addresses set (but
  79  * there are no substantial problems if you set addresses for none or
  80  * for more than one interface).
  81  * Bridging will act before routing, but nothing prevents a machine
  82  * from doing both (modulo bugs in the implementation...).
  83  *
  84  * THINGS TO REMEMBER
  85  *  - bridging is incompatible with multicast routing on the same
  86  *    machine. There is not an easy fix to this.
  87  *  - be very careful when bridging VLANs
  88  *  - loop detection is still not very robust.
  89  */
  90
  91 #include <sys/param.h>
  92 #include <sys/mbuf.h>
  93 #include <sys/malloc.h>
  94 #include <sys/protosw.h>
  95 #include <sys/systm.h>
  96 #include <sys/socket.h> /* for net/if.h */
  97 #include <sys/ctype.h>  /* string functions */
  98 #include <sys/kernel.h>
  99 #include <sys/module.h>
 100 #include <sys/sysctl.h>
 101
 102 #include <net/ethernet.h>
 103 #include <net/if.h>
 104 #include <net/if_arp.h>         /* for struct arpcom */
 105 #include <net/if_types.h>
 106 #include <net/if_var.h>
 107 #include <net/pfil.h>
 108
 109 #include <netinet/in.h>
 110 #include <netinet/in_systm.h>
 111 #include <netinet/in_var.h>
 112 #include <netinet/ip.h>
 113 #include <netinet/ip_var.h>
 114
 115 #include <net/route.h>
 116 #include <netinet/ip_fw.h>
 117 #include <netinet/ip_dummynet.h>
 118 #include <net/bridge.h>
 119
 120 /*--------------------*/
 121
 122 #define ETHER_ADDR_COPY(_dst,_src)      bcopy(_src, _dst, ETHER_ADDR_LEN)
 123 #define ETHER_ADDR_EQ(_a1,_a2)          (bcmp(_a1, _a2, ETHER_ADDR_LEN) == 0)
 124
 125 /*
 126  * For each cluster, source MAC addresses are stored into a hash
 127  * table which locates the port they reside on.
 128  */
 129 #define HASH_SIZE 8192  /* Table size, must be a power of 2 */
 130
 131 typedef struct hash_table {             /* each entry.          */
 132     struct ifnet *      name;
 133     u_char              etheraddr[ETHER_ADDR_LEN];
 134     u_int16_t           used;           /* also, padding        */
 135 } bdg_hash_table ;
 136
 137 /*
 138  * The hash function applied to MAC addresses. Out of the 6 bytes,
 139  * the last ones tend to vary more. Since we are on a little endian machine,
 140  * we have to do some gimmick...
 141  */
 142 #define HASH_FN(addr)   (       \
 143     ntohs( ((u_int16_t *)addr)[1] ^ ((u_int16_t *)addr)[2] ) & (HASH_SIZE -1))
 144
 145 /*
 146  * This is the data structure where local addresses are stored.
 147  */
 148 struct bdg_addr {
 149     u_char      etheraddr[ETHER_ADDR_LEN];
 150     u_int16_t   _padding;
 151 };
 152
 153 /*
 154  * The configuration of each cluster includes the cluster id, a pointer to
 155  * the hash table, and an array of local MAC addresses (of size "ports").
 156  */
 157 struct cluster_softc {
 158     u_int16_t   cluster_id;
 159     u_int16_t   ports;
 160     bdg_hash_table *ht;
 161     struct bdg_addr     *my_macs;       /* local MAC addresses */
 162 };
 163
 164
 165 extern struct protosw inetsw[];                 /* from netinet/ip_input.c */
 166
 167 static int n_clusters;                          /* number of clusters */
 168 static struct cluster_softc *clusters;
 169
 170 static struct mtx bdg_mtx;
 171 #define BDG_LOCK_INIT()         mtx_init(&bdg_mtx, "bridge", NULL, MTX_DEF)
 172 #define BDG_LOCK_DESTROY()      mtx_destroy(&bdg_mtx)
 173 #define BDG_LOCK()              mtx_lock(&bdg_mtx)
 174 #define BDG_UNLOCK()            mtx_unlock(&bdg_mtx)
 175 #define BDG_LOCK_ASSERT()       mtx_assert(&bdg_mtx, MA_OWNED)
 176
 177 #define BDG_MUTED(ifp) (ifp2sc[ifp->if_index].flags & IFF_MUTE)
 178 #define BDG_MUTE(ifp) ifp2sc[ifp->if_index].flags |= IFF_MUTE
 179 #define BDG_CLUSTER(ifp) (ifp2sc[ifp->if_index].cluster)
 180
 181 #define BDG_SAMECLUSTER(ifp,src) \
 182         (src == NULL || BDG_CLUSTER(ifp) == BDG_CLUSTER(src) )
 183
 184 #ifdef __i386__
 185 #define BDG_MATCH(a,b) ( \
 186     ((u_int16_t *)(a))[2] == ((u_int16_t *)(b))[2] && \
 187     *((u_int32_t *)(a)) == *((u_int32_t *)(b)) )
 188 #define IS_ETHER_BROADCAST(a) ( \
 189         *((u_int32_t *)(a)) == 0xffffffff && \
 190         ((u_int16_t *)(a))[2] == 0xffff )
 191 #else
 192 /* for machines that do not support unaligned access */
 193 #define BDG_MATCH(a,b)          ETHER_ADDR_EQ(a,b)
 194 #define IS_ETHER_BROADCAST(a)   ETHER_ADDR_EQ(a,"\377\377\377\377\377\377")
 195 #endif
 196
 197 SYSCTL_DECL(_net_link_ether);
 198 SYSCTL_NODE(_net_link_ether, OID_AUTO, bridge, CTLFLAG_RD, 0,
 199         "Bridge parameters");
 200 static char bridge_version[] = "031224";
 201 SYSCTL_STRING(_net_link_ether_bridge, OID_AUTO, version, CTLFLAG_RD,
 202         bridge_version, 0, "software version");
 203
 204 #define BRIDGE_DEBUG
 205 #ifdef BRIDGE_DEBUG
 206 int     bridge_debug = 0;
 207 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, debug, CTLFLAG_RW, &bridge_debug,
 208             0, "control debugging printfs");
 209 #define DPRINTF(X)      if (bridge_debug) printf X
 210 #else
 211 #define DPRINTF(X)
 212 #endif
 213
 214 #ifdef BRIDGE_TIMING
 215 /*
 216  * For timing-related debugging, you can use the following macros.
 217  * remember, rdtsc() only works on Pentium-class machines
 218
 219     quad_t ticks;
 220     DDB(ticks = rdtsc();)
 221     ... interesting code ...
 222     DDB(bdg_fw_ticks += (u_long)(rdtsc() - ticks) ; bdg_fw_count++ ;)
 223
 224  *
 225  */
 226 #define DDB(x)  x
 227
 228 static int bdg_fw_avg;
 229 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, fw_avg, CTLFLAG_RW,
 230             &bdg_fw_avg, 0,"Cycle counter avg");
 231 static int bdg_fw_ticks;
 232 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, fw_ticks, CTLFLAG_RW,
 233             &bdg_fw_ticks, 0,"Cycle counter item");
 234 static int bdg_fw_count;
 235 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, fw_count, CTLFLAG_RW,
 236             &bdg_fw_count, 0,"Cycle counter count");
 237 #else
 238 #define DDB(x)
 239 #endif
 240
 241 static int bdginit(void);
 242 static void parse_bdg_cfg(void);
 243 static struct mbuf *bdg_forward(struct mbuf *, struct ifnet *);
 244
 245 static int bdg_ipf;             /* IPFilter enabled in bridge */
 246 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, ipf, CTLFLAG_RW,
 247             &bdg_ipf, 0,"Pass bridged pkts through IPFilter");
 248 static int bdg_ipfw;
 249 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, ipfw, CTLFLAG_RW,
 250             &bdg_ipfw,0,"Pass bridged pkts through firewall");
 251
 252 static int bdg_copy;
 253 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, copy, CTLFLAG_RW,
 254         &bdg_copy, 0, "Force packet copy in bdg_forward");
 255
 256 int bdg_ipfw_drops;
 257 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, ipfw_drop,
 258         CTLFLAG_RW, &bdg_ipfw_drops,0,"");
 259 int bdg_ipfw_colls;
 260 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, ipfw_collisions,
 261         CTLFLAG_RW, &bdg_ipfw_colls,0,"");
 262
 263 static int bdg_thru;
 264 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, packets, CTLFLAG_RW,
 265         &bdg_thru, 0, "Packets through bridge");
 266 static int bdg_dropped;
 267 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, dropped, CTLFLAG_RW,
 268         &bdg_dropped, 0, "Packets dropped in bdg_forward");
 269 static int bdg_predict;
 270 SYSCTL_INT(_net_link_ether_bridge, OID_AUTO, predict, CTLFLAG_RW,
 271         &bdg_predict, 0, "Correctly predicted header location");
 272
 273 #ifdef BRIDGE_DEBUG
 274 static char *bdg_dst_names[] = {
 275         "BDG_NULL    ",
 276         "BDG_BCAST   ",
 277         "BDG_MCAST   ",
 278         "BDG_LOCAL   ",
 279         "BDG_DROP    ",
 280         "BDG_UNKNOWN ",
 281         "BDG_IN      ",
 282         "BDG_OUT     ",
 283         "BDG_FORWARD " };
 284 #endif /* BRIDGE_DEBUG */
 285
 286 /*
 287  * System initialization
 288  */
 289 static struct bdg_stats bdg_stats ;
 290 SYSCTL_STRUCT(_net_link_ether_bridge, OID_AUTO, stats, CTLFLAG_RD,
 291         &bdg_stats, bdg_stats, "bridge statistics");
 292
 293 static struct callout bdg_callout;
 294
 295 /*
 296  * Add an interface to a cluster, possibly creating a new entry in
 297  * the cluster table. This requires reallocation of the table and
 298  * updating pointers in ifp2sc.
 299  */
 300 static struct cluster_softc *
 301 add_cluster(u_int16_t cluster_id, struct ifnet *ifp)
 302 {
 303     struct cluster_softc *c = NULL;
 304     int i;
 305
 306     BDG_LOCK_ASSERT();
 307
 308     for (i = 0; i < n_clusters ; i++)
 309         if (clusters[i].cluster_id == cluster_id)
 310             goto found;
 311
 312     /* Not found, need to reallocate */
 313     c = malloc((1+n_clusters) * sizeof (*c), M_IFADDR, M_NOWAIT | M_ZERO);
 314     if (c == NULL) {/* malloc failure */
 315         printf("-- bridge: cannot add new cluster\n");
 316         goto bad;
 317     }
 318     c[n_clusters].ht = (struct hash_table *)
 319             malloc(HASH_SIZE * sizeof(struct hash_table),
 320                 M_IFADDR, M_NOWAIT | M_ZERO);
 321     if (c[n_clusters].ht == NULL) {
 322         printf("-- bridge: cannot allocate hash table for new cluster\n");
 323         goto bad;
 324     }
 325     c[n_clusters].my_macs = (struct bdg_addr *)
 326             malloc(BDG_MAX_PORTS * sizeof(struct bdg_addr),
 327                 M_IFADDR, M_NOWAIT | M_ZERO);
 328     if (c[n_clusters].my_macs == NULL) {
 329         printf("-- bridge: cannot allocate mac addr table for new cluster\n");
 330         free(c[n_clusters].ht, M_IFADDR);
 331         goto bad;
 332     }
 333
 334     c[n_clusters].cluster_id = cluster_id;
 335     c[n_clusters].ports = 0;
 336     /*
 337      * now copy old descriptors here
 338      */
 339     if (n_clusters > 0) {
 340         for (i=0; i < n_clusters; i++)
 341             c[i] = clusters[i];
 342         /*
 343          * and finally update pointers in ifp2sc
 344          */
 345         for (i = 0 ; i < if_index && i < BDG_MAX_PORTS; i++)
 346             if (ifp2sc[i].cluster != NULL)
 347                 ifp2sc[i].cluster = c + (ifp2sc[i].cluster - clusters);
 348         free(clusters, M_IFADDR);
 349     }
 350     clusters = c;
 351     i = n_clusters;             /* index of cluster entry */
 352     n_clusters++;
 353 found:
 354     c = clusters + i;           /* the right cluster ... */
 355     ETHER_ADDR_COPY(c->my_macs[c->ports].etheraddr, IFP2ENADDR(ifp));
 356     c->ports++;
 357     return c;
 358 bad:
 359     if (c)
 360         free(c, M_IFADDR);
 361     return NULL;
 362 }
 363
 364
 365 /*
 366  * Turn off bridging, by clearing promisc mode on the interface,
 367  * marking the interface as unused, and clearing the name in the
 368  * stats entry.
 369  * Also dispose the hash tables associated with the clusters.
 370  */
 371 static void
 372 bridge_off(void)
 373 {
 374     struct ifnet *ifp ;
 375     int i;
 376
 377     BDG_LOCK_ASSERT();
 378
 379     DPRINTF(("%s: n_clusters %d\n", __func__, n_clusters));
 380
 381     IFNET_RLOCK();
 382     TAILQ_FOREACH(ifp, &ifnet, if_link) {
 383         struct bdg_softc *b;
 384
 385         if (ifp->if_index >= BDG_MAX_PORTS)
 386             continue;   /* make sure we do not go beyond the end */
 387         b = &ifp2sc[ifp->if_index];
 388
 389         if ( b->flags & IFF_BDG_PROMISC ) {
 390             ifpromisc(ifp, 0);
 391             b->flags &= ~(IFF_BDG_PROMISC|IFF_MUTE) ;
 392             DPRINTF(("%s: %s promisc OFF if_flags 0x%x "
 393                 "bdg_flags 0x%x\n", __func__, ifp->if_xname,
 394                 ifp->if_flags, b->flags));
 395         }
 396         b->flags &= ~(IFF_USED) ;
 397         b->cluster = NULL;
 398         bdg_stats.s[ifp->if_index].name[0] = '\0';
 399     }
 400     IFNET_RUNLOCK();
 401     /* flush_tables */
 402
 403     for (i=0; i < n_clusters; i++) {
 404         free(clusters[i].ht, M_IFADDR);
 405         free(clusters[i].my_macs, M_IFADDR);
 406     }
 407     if (clusters != NULL)
 408         free(clusters, M_IFADDR);
 409     clusters = NULL;
 410     n_clusters =0;
 411 }
 412
 413 /*
 414  * set promisc mode on the interfaces we use.
 415  */
 416 static void
 417 bridge_on(void)
 418 {
 419     struct ifnet *ifp ;
 420
 421     BDG_LOCK_ASSERT();
 422
 423     IFNET_RLOCK();
 424     TAILQ_FOREACH(ifp, &ifnet, if_link) {
 425         struct bdg_softc *b = &ifp2sc[ifp->if_index];
 426
 427         if ( !(b->flags & IFF_USED) )
 428             continue ;
 429         if ( !( ifp->if_flags & IFF_UP) ) {
 430             if_up(ifp);
 431         }
 432         if ( !(b->flags & IFF_BDG_PROMISC) ) {
 433             (void) ifpromisc(ifp, 1);
 434             b->flags |= IFF_BDG_PROMISC ;
 435             DPRINTF(("%s: %s promisc ON if_flags 0x%x bdg_flags 0x%x\n",
 436                 __func__, ifp->if_xname, ifp->if_flags, b->flags));
 437         }
 438         if (b->flags & IFF_MUTE) {
 439             DPRINTF(("%s: unmuting %s\n", __func__, ifp->if_xname));
 440             b->flags &= ~IFF_MUTE;
 441         }
 442     }
 443     IFNET_RUNLOCK();
 444 }
 445
 446 static char bridge_cfg[1024];           /* NB: in BSS so initialized to zero */
 447
 448 /**
 449  * reconfigure bridge.
 450  * This is also done every time we attach or detach an interface.
 451  * Main use is to make sure that we do not bridge on some old
 452  * (ejected) device. So, it would be really useful to have a
 453  * pointer to the modified device as an argument. Without it, we
 454  * have to scan all interfaces.
 455  */
 456 static void
 457 reconfigure_bridge_locked(void)
 458 {
 459     BDG_LOCK_ASSERT();
 460
 461     bridge_off();
 462     if (do_bridge) {
 463         if (if_index >= BDG_MAX_PORTS) {
 464             printf("-- sorry too many interfaces (%d, max is %d),"
 465                 " disabling bridging\n", if_index, BDG_MAX_PORTS);
 466             do_bridge = 0;
 467             return;
 468         }
 469         parse_bdg_cfg();
 470         bridge_on();
 471     }
 472 }
 473
 474 static void
 475 reconfigure_bridge(void)
 476 {
 477     BDG_LOCK();
 478     reconfigure_bridge_locked();
 479     BDG_UNLOCK();
 480 }
 481
 482 /*
 483  * parse the config string, set IFF_USED, name and cluster_id
 484  * for all interfaces found.
 485  * The config string is a list of "if[:cluster]" with
 486  * a number of possible separators (see "sep"). In particular the
 487  * use of the space lets you set bridge_cfg with the output from
 488  * "ifconfig -l"
 489  */
 490 static void
 491 parse_bdg_cfg(void)
 492 {
 493     char *p, *beg;
 494     int l, cluster;
 495     static const char *sep = ", \t";
 496
 497     BDG_LOCK_ASSERT();
 498
 499     for (p = bridge_cfg; *p ; p++) {
 500         struct ifnet *ifp;
 501         int found = 0;
 502         char c;
 503
 504         if (index(sep, *p))     /* skip separators */
 505             continue ;
 506         /* names are lowercase and digits */
 507         for ( beg = p ; islower(*p) || isdigit(*p) ; p++ )
 508             ;
 509         l = p - beg ;           /* length of name string */
 510         if (l == 0)             /* invalid name */
 511             break ;
 512         if ( *p != ':' )        /* no ':', assume default cluster 1 */
 513             cluster = 1 ;
 514         else                    /* fetch cluster */
 515             cluster = strtoul( p+1, &p, 10);
 516         c = *p;
 517         *p = '\0';
 518         /*
 519          * now search in interface list for a matching name
 520          */
 521         IFNET_RLOCK();          /* could sleep XXX */
 522         TAILQ_FOREACH(ifp, &ifnet, if_link) {
 523
 524             if (!strncmp(beg, ifp->if_xname, max(l, strlen(ifp->if_xname)))) {
 525                 struct bdg_softc *b = &ifp2sc[ifp->if_index];
 526                 if (ifp->if_type != IFT_ETHER && ifp->if_type != IFT_L2VLAN) {
 527                     printf("%s is not an ethernet, continue\n", ifp->if_xname);
 528                     continue;
 529                 }
 530                 if (b->flags & IFF_USED) {
 531                     printf("%s already used, skipping\n", ifp->if_xname);
 532                     break;
 533                 }
 534                 b->cluster = add_cluster(htons(cluster), ifp);
 535                 b->flags |= IFF_USED ;
 536                 snprintf(bdg_stats.s[ifp->if_index].name,
 537                     sizeof(bdg_stats.s[ifp->if_index].name),
 538                     "%s:%d", ifp->if_xname, cluster);
 539
 540                 DPRINTF(("%s: found %s next c %d\n", __func__,
 541                     bdg_stats.s[ifp->if_index].name, c));
 542                 found = 1;
 543                 break ;
 544             }
 545         }
 546         IFNET_RUNLOCK();
 547         if (!found)
 548             printf("interface %s Not found in bridge\n", beg);
 549         *p = c;
 550         if (c == '\0')
 551             break; /* no more */
 552     }
 553 }
 554
 555 /*
 556  * handler for net.link.ether.bridge
 557  */
 558 static int
 559 sysctl_bdg(SYSCTL_HANDLER_ARGS)
 560 {
 561     int enable = do_bridge;
 562     int error;
 563
 564     error = sysctl_handle_int(oidp, &enable, 0, req);
 565     enable = (enable) ? 1 : 0;
 566     BDG_LOCK();
 567     if (enable != do_bridge) {
 568         do_bridge = enable;
 569         reconfigure_bridge_locked();
 570     }
 571     BDG_UNLOCK();
 572     return error ;
 573 }
 574 SYSCTL_PROC(_net_link_ether_bridge, OID_AUTO, enable, CTLTYPE_INT|CTLFLAG_RW,
 575             &do_bridge, 0, &sysctl_bdg, "I", "Bridging");
 576
 577 /*
 578  * handler for net.link.ether.bridge_cfg
 579  */
 580 static int
 581 sysctl_bdg_cfg(SYSCTL_HANDLER_ARGS)
 582 {
 583     int error;
 584     char *new_cfg;
 585
 586     new_cfg = malloc(sizeof(bridge_cfg), M_TEMP, M_WAITOK);
 587     bcopy(bridge_cfg, new_cfg, sizeof(bridge_cfg));
 588
 589     error = sysctl_handle_string(oidp, new_cfg, oidp->oid_arg2, req);
 590     if (error == 0) {
 591         BDG_LOCK();
 592         if (strcmp(new_cfg, bridge_cfg)) {
 593             bcopy(new_cfg, bridge_cfg, sizeof(bridge_cfg));
 594             reconfigure_bridge_locked();
 595         }
 596         BDG_UNLOCK();
 597     }
 598
 599     free(new_cfg, M_TEMP);
 600
 601     return error;
 602 }
 603 SYSCTL_PROC(_net_link_ether_bridge, OID_AUTO, config, CTLTYPE_STRING|CTLFLAG_RW,
 604             &bridge_cfg, sizeof(bridge_cfg), &sysctl_bdg_cfg, "A",
 605             "Bridge configuration");
 606
 607 static int
 608 sysctl_refresh(SYSCTL_HANDLER_ARGS)
 609 {
 610     if (req->newptr)
 611         reconfigure_bridge();
 612
 613     return 0;
 614 }
 615 SYSCTL_PROC(_net_link_ether_bridge, OID_AUTO, refresh, CTLTYPE_INT|CTLFLAG_WR,
 616             NULL, 0, &sysctl_refresh, "I", "iface refresh");
 617
 618 #ifndef BURN_BRIDGES
 619 #define SYSCTL_OID_COMPAT(parent, nbr, name, kind, a1, a2, handler, fmt, descr)\
 620         static struct sysctl_oid sysctl__##parent##_##name##_compat = {  \
 621                 &sysctl_##parent##_children, { 0 },                      \
 622                 nbr, kind, a1, a2, #name, handler, fmt, 0, descr };      \
 623         DATA_SET(sysctl_set, sysctl__##parent##_##name##_compat)
 624 #define SYSCTL_INT_COMPAT(parent, nbr, name, access, ptr, val, descr)    \
 625         SYSCTL_OID_COMPAT(parent, nbr, name, CTLTYPE_INT|(access),       \
 626                 ptr, val, sysctl_handle_int, "I", descr)
 627 #define SYSCTL_STRUCT_COMPAT(parent, nbr, name, access, ptr, type, descr)\
 628         SYSCTL_OID_COMPAT(parent, nbr, name, CTLTYPE_OPAQUE|(access),    \
 629                 ptr, sizeof(struct type), sysctl_handle_opaque,          \
 630                 "S," #type, descr)
 631 #define SYSCTL_PROC_COMPAT(parent, nbr, name, access, ptr, arg, handler, fmt, descr) \
 632         SYSCTL_OID_COMPAT(parent, nbr, name, (access),                   \
 633                 ptr, arg, handler, fmt, descr)
 634
 635 SYSCTL_INT_COMPAT(_net_link_ether, OID_AUTO, bridge_ipf, CTLFLAG_RW,
 636             &bdg_ipf, 0,"Pass bridged pkts through IPFilter");
 637 SYSCTL_INT_COMPAT(_net_link_ether, OID_AUTO, bridge_ipfw, CTLFLAG_RW,
 638             &bdg_ipfw,0,"Pass bridged pkts through firewall");
 639 SYSCTL_STRUCT_COMPAT(_net_link_ether, PF_BDG, bdgstats, CTLFLAG_RD,
 640         &bdg_stats, bdg_stats, "bridge statistics");
 641 SYSCTL_PROC_COMPAT(_net_link_ether, OID_AUTO, bridge_cfg,
 642             CTLTYPE_STRING|CTLFLAG_RW,
 643             &bridge_cfg, sizeof(bridge_cfg), &sysctl_bdg_cfg, "A",
 644             "Bridge configuration");
 645 SYSCTL_PROC_COMPAT(_net_link_ether, OID_AUTO, bridge_refresh,
 646             CTLTYPE_INT|CTLFLAG_WR,
 647             NULL, 0, &sysctl_refresh, "I", "iface refresh");
 648 #endif
 649
 650 static int bdg_loops;
 651 static int bdg_slowtimer = 0;
 652 static int bdg_age_index = 0;   /* index of table position to age */
 653
 654 /*
 655  * called periodically to flush entries etc.
 656  */
 657 static void
 658 bdg_timeout(void *dummy)
 659 {
 660     if (do_bridge) {
 661         int l, i;
 662
 663         BDG_LOCK();
 664         /*
 665          * age entries in the forwarding table.
 666          */
 667         l = bdg_age_index + HASH_SIZE/4 ;
 668         if (l > HASH_SIZE)
 669             l = HASH_SIZE;
 670
 671         for (i = 0; i < n_clusters; i++) {
 672             bdg_hash_table *bdg_table = clusters[i].ht;
 673             for (; bdg_age_index < l; bdg_age_index++)
 674                 if (bdg_table[bdg_age_index].used)
 675                     bdg_table[bdg_age_index].used = 0;
 676                 else if (bdg_table[bdg_age_index].name) {
 677                     DPRINTF(("%s: flushing stale entry %d\n",
 678                         __func__, bdg_age_index));
 679                     bdg_table[bdg_age_index].name = NULL;
 680                 }
 681         }
 682         if (bdg_age_index >= HASH_SIZE)
 683             bdg_age_index = 0;
 684
 685         if (--bdg_slowtimer <= 0 ) {
 686             bdg_slowtimer = 5;
 687
 688             bridge_on();        /* we just need unmute, really */
 689             bdg_loops = 0;
 690         }
 691         BDG_UNLOCK();
 692     }
 693     callout_reset(&bdg_callout, 2*hz, bdg_timeout, NULL);
 694 }
 695
 696 /*
 697  * Find the right pkt destination:
 698  *      BDG_BCAST       is a broadcast
 699  *      BDG_MCAST       is a multicast
 700  *      BDG_LOCAL       is for a local address
 701  *      BDG_DROP        must be dropped
 702  *      other           ifp of the dest. interface (incl.self)
 703  *
 704  * We assume this is only called for interfaces for which bridging
 705  * is enabled, i.e. BDG_USED(ifp) is true.
 706  */
 707 static __inline struct ifnet *
 708 bridge_dst_lookup(struct ether_header *eh, struct cluster_softc *c)
 709 {
 710     bdg_hash_table *bt;         /* pointer to entry in hash table */
 711
 712     BDG_LOCK_ASSERT();
 713
 714     if (ETHER_IS_MULTICAST(eh->ether_dhost))
 715         return IS_ETHER_BROADCAST(eh->ether_dhost) ? BDG_BCAST : BDG_MCAST;
 716     /*
 717      * Lookup local addresses in case one matches.  We optimize
 718      * for the common case of two interfaces.
 719      */
 720     KASSERT(c->ports != 0, ("lookup with no ports!"));
 721     switch (c->ports) {
 722         int i;
 723     default:
 724         for (i = c->ports-1; i > 1; i--) {
 725             if (ETHER_ADDR_EQ(c->my_macs[i].etheraddr, eh->ether_dhost))
 726                 return BDG_LOCAL;
 727         }
 728         /* fall thru... */
 729     case 2:
 730         if (ETHER_ADDR_EQ(c->my_macs[1].etheraddr, eh->ether_dhost))
 731             return BDG_LOCAL;
 732     case 1:
 733         if (ETHER_ADDR_EQ(c->my_macs[0].etheraddr, eh->ether_dhost))
 734             return BDG_LOCAL;
 735     }
 736     /*
 737      * Look for a possible destination in table
 738      */
 739     bt = &c->ht[HASH_FN(eh->ether_dhost)];
 740     if (bt->name && ETHER_ADDR_EQ(bt->etheraddr, eh->ether_dhost))
 741         return bt->name;
 742     else
 743         return BDG_UNKNOWN;
 744 }
 745
 746 /**
 747  * bridge_in() is invoked to perform bridging decision on input packets.
 748  *
 749  * On Input:
 750  *   eh         Ethernet header of the incoming packet.
 751  *   ifp        interface the packet is coming from.
 752  *
 753  * On Return: destination of packet, one of
 754  *   BDG_BCAST  broadcast
 755  *   BDG_MCAST  multicast
 756  *   BDG_LOCAL  is only for a local address (do not forward)
 757  *   BDG_DROP   drop the packet
 758  *   ifp        ifp of the destination interface.
 759  *
 760  * Forwarding is not done directly to give a chance to some drivers
 761  * to fetch more of the packet, or simply drop it completely.
 762  */
 763
 764 static struct mbuf *
 765 bridge_in(struct ifnet *ifp, struct mbuf *m)
 766 {
 767     struct ether_header *eh;
 768     struct ifnet *dst, *old;
 769     bdg_hash_table *bt;                 /* location in hash table */
 770     int dropit = BDG_MUTED(ifp);
 771     int index;
 772
 773     eh = mtod(m, struct ether_header *);
 774
 775     /*
 776      * hash the source address
 777      */
 778     BDG_LOCK();
 779     index = HASH_FN(eh->ether_shost);
 780     bt = &BDG_CLUSTER(ifp)->ht[index];
 781     bt->used = 1;
 782     old = bt->name;
 783     if (old) {                          /* the entry is valid */
 784         if (!ETHER_ADDR_EQ(eh->ether_shost, bt->etheraddr)) {
 785             bdg_ipfw_colls++;
 786             bt->name = NULL;            /* NB: will overwrite below */
 787         } else if (old != ifp) {
 788             /*
 789              * Found a loop. Either a machine has moved, or there
 790              * is a misconfiguration/reconfiguration of the network.
 791              * First, do not forward this packet!
 792              * Record the relocation anyways; then, if loops persist,
 793              * suspect a reconfiguration and disable forwarding
 794              * from the old interface.
 795              */
 796             bt->name = ifp;             /* relocate address */
 797             printf("-- loop (%d) %6D to %s from %s (%s)\n",
 798                         bdg_loops, eh->ether_shost, ".",
 799                         ifp->if_xname, old->if_xname,
 800                         BDG_MUTED(old) ? "muted":"active");
 801             dropit = 1;
 802             if (!BDG_MUTED(old)) {
 803                 if (bdg_loops++ > 10)
 804                     BDG_MUTE(old);
 805             }
 806         }
 807     }
 808
 809     /*
 810      * now write the source address into the table
 811      */
 812     if (bt->name == NULL) {
 813         DPRINTF(("%s: new addr %6D at %d for %s\n",
 814             __func__, eh->ether_shost, ".", index, ifp->if_xname));
 815         ETHER_ADDR_COPY(bt->etheraddr, eh->ether_shost);
 816         bt->name = ifp;
 817     }
 818     dst = bridge_dst_lookup(eh, BDG_CLUSTER(ifp));
 819     BDG_UNLOCK();
 820
 821     /*
 822      * bridge_dst_lookup can return the following values:
 823      *   BDG_BCAST, BDG_MCAST, BDG_LOCAL, BDG_UNKNOWN, BDG_DROP, ifp.
 824      * For muted interfaces, or when we detect a loop, the first 3 are
 825      * changed in BDG_LOCAL (we still listen to incoming traffic),
 826      * and others to BDG_DROP (no use for the local host).
 827      * Also, for incoming packets, ifp is changed to BDG_DROP if ifp == src.
 828      * These changes are not necessary for outgoing packets from ether_output().
 829      */
 830     BDG_STAT(ifp, BDG_IN);
 831     switch ((uintptr_t)dst) {
 832     case (uintptr_t)BDG_BCAST:
 833     case (uintptr_t)BDG_MCAST:
 834     case (uintptr_t)BDG_LOCAL:
 835     case (uintptr_t)BDG_UNKNOWN:
 836     case (uintptr_t)BDG_DROP:
 837         BDG_STAT(ifp, dst);
 838         break;
 839     default:
 840         if (dst == ifp || dropit)
 841             BDG_STAT(ifp, BDG_DROP);
 842         else
 843             BDG_STAT(ifp, BDG_FORWARD);
 844         break;
 845     }
 846
 847     if (dropit) {
 848         if (dst == BDG_BCAST || dst == BDG_MCAST || dst == BDG_LOCAL)
 849             dst = BDG_LOCAL;
 850         else
 851             dst = BDG_DROP;
 852     } else {
 853         if (dst == ifp)
 854             dst = BDG_DROP;
 855     }
 856     DPRINTF(("%s: %6D ->%6D ty 0x%04x dst %s\n", __func__,
 857         eh->ether_shost, ".",
 858         eh->ether_dhost, ".",
 859         ntohs(eh->ether_type),
 860         (dst <= BDG_FORWARD) ? bdg_dst_names[(uintptr_t)dst] :
 861                 dst->if_xname));
 862
 863     switch ((uintptr_t)dst) {
 864     case (uintptr_t)BDG_DROP:
 865         m_freem(m);
 866         return (NULL);
 867
 868     case (uintptr_t)BDG_LOCAL:
 869         return (m);
 870
 871     case (uintptr_t)BDG_BCAST:
 872     case (uintptr_t)BDG_MCAST:
 873         m = bdg_forward(m, dst);
 874 #ifdef  DIAGNOSTIC
 875         if (m == NULL)
 876                 if_printf(ifp, "bridge dropped %s packet\n",
 877                      dst == BDG_BCAST ? "broadcast" : "multicast");
 878 #endif
 879         return (m);
 880
 881     default:
 882         m = bdg_forward(m, dst);
 883         /*
 884          * But in some cases the bridge may return the
 885          * packet for us to free; sigh.
 886          */
 887         if (m != NULL)
 888                 m_freem(m);
 889
 890     }
 891
 892     return (NULL);
 893 }
 894
 895 /*
 896  * Return 1 if it's ok to send a packet out the specified interface.
 897  * The interface must be:
 898  *      used for bridging,
 899  *      not muted,
 900  *      not full,
 901  *      up and running,
 902  *      not the source interface, and
 903  *      belong to the same cluster as the 'real_dst'.
 904  */
 905 static __inline int
 906 bridge_ifok(struct ifnet *ifp, struct ifnet *src, struct ifnet *dst)
 907 {
 908     return (BDG_USED(ifp)
 909         && !BDG_MUTED(ifp)
 910         && !_IF_QFULL(&ifp->if_snd)
 911         && (ifp->if_flags & (IFF_UP|IFF_RUNNING)) == (IFF_UP|IFF_RUNNING)
 912         && ifp != src
 913         && BDG_SAMECLUSTER(ifp, dst));
 914 }
 915
 916 /*
 917  * Forward a packet to dst -- which can be a single interface or
 918  * an entire cluster. The src port and muted interfaces are excluded.
 919  *
 920  * If src == NULL, the pkt comes from ether_output, and dst is the real
 921  * interface the packet is originally sent to. In this case, we must forward
 922  * it to the whole cluster.
 923  * We never call bdg_forward from ether_output on interfaces which are
 924  * not part of a cluster.
 925  *
 926  * If possible (i.e. we can determine that the caller does not need
 927  * a copy), the packet is consumed here, and bdg_forward returns NULL.
 928  * Otherwise, a pointer to a copy of the packet is returned.
 929  */
 930 static struct mbuf *
 931 bdg_forward(struct mbuf *m0, struct ifnet *dst)
 932 {
 933 #define EH_RESTORE(_m) do {                                                \
 934     M_PREPEND((_m), ETHER_HDR_LEN, M_DONTWAIT);                            \
 935     if ((_m) == NULL) {                                                    \
 936         bdg_dropped++;                                                     \
 937         return NULL;                                                       \
 938     }                                                                      \
 939     if (eh != mtod((_m), struct ether_header *))                           \
 940         bcopy(&save_eh, mtod((_m), struct ether_header *), ETHER_HDR_LEN); \
 941     else                                                                   \
 942         bdg_predict++;                                                     \
 943 } while (0);
 944     struct ether_header *eh;
 945     struct ifnet *src;
 946     struct ifnet *ifp, *last;
 947     int shared = bdg_copy;              /* someone else is using the mbuf */
 948     int error;
 949     struct ifnet *real_dst = dst;       /* real dst from ether_output */
 950     struct ip_fw_args args;
 951     struct ether_header save_eh;
 952     struct mbuf *m;
 953
 954     DDB(quad_t ticks; ticks = rdtsc();)
 955
 956     args.rule = ip_dn_claim_rule(m0);
 957     if (args.rule)
 958         shared = 0;                     /* For sure this is our own mbuf. */
 959     else
 960         bdg_thru++;                     /* count 1st time through bdg_forward */
 961
 962     /*
 963      * The packet arrives with the Ethernet header at the front.
 964      */
 965     eh = mtod(m0, struct ether_header *);
 966
 967     src = m0->m_pkthdr.rcvif;
 968     if (src == NULL) {                  /* packet from ether_output */
 969         BDG_LOCK();
 970         dst = bridge_dst_lookup(eh, BDG_CLUSTER(real_dst));
 971         BDG_UNLOCK();
 972     }
 973
 974     if (dst == BDG_DROP) {              /* this should not happen */
 975         printf("xx bdg_forward for BDG_DROP\n");
 976         m_freem(m0);
 977         bdg_dropped++;
 978         return NULL;
 979     }
 980     if (dst == BDG_LOCAL) {             /* this should not happen as well */
 981         printf("xx ouch, bdg_forward for local pkt\n");
 982         return m0;
 983     }
 984     if (dst == BDG_BCAST || dst == BDG_MCAST) {
 985          /* need a copy for the local stack */
 986          shared = 1;
 987     }
 988
 989     /*
 990      * Do filtering in a very similar way to what is done in ip_output.
 991      * Only if firewall is loaded, enabled, and the packet is not
 992      * from ether_output() (src==NULL, or we would filter it twice).
 993      * Additional restrictions may apply e.g. non-IP, short packets,
 994      * and pkts already gone through a pipe.
 995      */
 996     if (src != NULL && (
 997         (inet_pfil_hook.ph_busy_count >= 0 && bdg_ipf != 0) ||
 998         (IPFW_LOADED && bdg_ipfw != 0))) {
 999
1000         int i;
1001
1002         if (args.rule != NULL && fw_one_pass)
1003             goto forward; /* packet already partially processed */
1004         /*
1005          * i need some amt of data to be contiguous, and in case others need
1006          * the packet (shared==1) also better be in the first mbuf.
1007          */
1008         i = min(m0->m_pkthdr.len, max_protohdr) ;
1009         if (shared || m0->m_len < i) {
1010             m0 = m_pullup(m0, i);
1011             if (m0 == NULL) {
1012                 printf("%s: m_pullup failed\n", __func__);      /* XXXDPRINTF*/
1013                 bdg_dropped++;
1014                 return NULL;
1015             }
1016             eh = mtod(m0, struct ether_header *);
1017         }
1018
1019         /*
1020          * Processing below expects the Ethernet header is stripped.
1021          * Furthermore, the mbuf chain might be replaced at various
1022          * places.  To deal with this we copy the header to a temporary
1023          * location, strip the header, and restore it as needed.
1024          */
1025         bcopy(eh, &save_eh, ETHER_HDR_LEN);     /* local copy for restore */
1026         m_adj(m0, ETHER_HDR_LEN);               /* temporarily strip header */
1027
1028         /*
1029          * NetBSD-style generic packet filter, pfil(9), hooks.
1030          * Enables ipf(8) in bridging.
1031          */
1032         if (!IPFW_LOADED) { /* XXX: Prevent ipfw from being run twice. */
1033         if (inet_pfil_hook.ph_busy_count >= 0 &&
1034             m0->m_pkthdr.len >= sizeof(struct ip) &&
1035             ntohs(save_eh.ether_type) == ETHERTYPE_IP) {
1036             /*
1037              * before calling the firewall, swap fields the same as IP does.
1038              * here we assume the pkt is an IP one and the header is contiguous
1039              */
1040             struct ip *ip = mtod(m0, struct ip *);
1041
1042             ip->ip_len = ntohs(ip->ip_len);
1043             ip->ip_off = ntohs(ip->ip_off);
1044
1045             if (pfil_run_hooks(&inet_pfil_hook, &m0, src, PFIL_IN, NULL) != 0) {
1046                 /* NB: hook should consume packet */
1047                 return NULL;
1048             }
1049             if (m0 == NULL)                     /* consumed by filter */
1050                 return m0;
1051             /*
1052              * If we get here, the firewall has passed the pkt, but the mbuf
1053              * pointer might have changed. Restore ip and the fields ntohs()'d.
1054              */
1055             ip = mtod(m0, struct ip *);
1056             ip->ip_len = htons(ip->ip_len);
1057             ip->ip_off = htons(ip->ip_off);
1058         }
1059         } /* XXX: Prevent ipfw from being run twice. */
1060
1061         /*
1062          * Prepare arguments and call the firewall.
1063          */
1064         if (!IPFW_LOADED || bdg_ipfw == 0) {
1065             EH_RESTORE(m0);     /* restore Ethernet header */
1066             goto forward;       /* not using ipfw, accept the packet */
1067         }
1068
1069         /*
1070          * XXX The following code is very similar to the one in
1071          * if_ethersubr.c:ether_ipfw_chk()
1072          */
1073
1074         args.m = m0;            /* the packet we are looking at         */
1075         args.oif = NULL;        /* this is an input packet              */
1076         args.next_hop = NULL;   /* we do not support forward yet        */
1077         args.eh = &save_eh;     /* MAC header for bridged/MAC packets   */
1078         i = ip_fw_chk_ptr(&args);
1079         m0 = args.m;            /* in case the firewall used the mbuf   */
1080
1081         if (m0 != NULL)
1082                 EH_RESTORE(m0); /* restore Ethernet header */
1083
1084         if (i == IP_FW_DENY) /* drop */
1085             return m0;
1086
1087         KASSERT(m0 != NULL, ("bdg_forward: m0 is NULL"));
1088
1089         if (i == 0) /* a PASS rule.  */
1090             goto forward;
1091         if (DUMMYNET_LOADED && (i == IP_FW_DUMMYNET)) {
1092             /*
1093              * Pass the pkt to dummynet, which consumes it.
1094              * If shared, make a copy and keep the original.
1095              */
1096             if (shared) {
1097                 m = m_copypacket(m0, M_DONTWAIT);
1098                 if (m == NULL) {        /* copy failed, give up */
1099                     bdg_dropped++;
1100                     return NULL;
1101                 }
1102             } else {
1103                 m = m0 ; /* pass the original to dummynet */
1104                 m0 = NULL ; /* and nothing back to the caller */
1105             }
1106
1107             args.oif = real_dst;
1108             ip_dn_io_ptr(m, DN_TO_BDG_FWD, &args);
1109             return m0;
1110         }
1111         /*
1112          * XXX at some point, add support for divert/forward actions.
1113          * If none of the above matches, we have to drop the packet.
1114          */
1115         bdg_ipfw_drops++;
1116         return m0;
1117     }
1118 forward:
1119     /*
1120      * Again, bring up the headers in case of shared bufs to avoid
1121      * corruptions in the future.
1122      */
1123     if (shared) {
1124         int i = min(m0->m_pkthdr.len, max_protohdr);
1125
1126         m0 = m_pullup(m0, i);
1127         if (m0 == NULL) {
1128             bdg_dropped++;
1129             return NULL;
1130         }
1131         /* NB: eh is not used below; no need to recalculate it */
1132     }
1133
1134     /*
1135      * now real_dst is used to determine the cluster where to forward.
1136      * For packets coming from ether_input, this is the one of the 'src'
1137      * interface, whereas for locally generated packets (src==NULL) it
1138      * is the cluster of the original destination interface, which
1139      * was already saved into real_dst.
1140      */
1141     if (src != NULL)
1142         real_dst = src;
1143
1144     last = NULL;
1145     if (dst == BDG_BCAST || dst == BDG_MCAST || dst == BDG_UNKNOWN) {
1146         /*
1147          * Scan all ports and send copies to all but the last.
1148          */
1149         IFNET_RLOCK();          /* XXX replace with generation # */
1150         TAILQ_FOREACH(ifp, &ifnet, if_link) {
1151             if (bridge_ifok(ifp, src, real_dst)) {
1152                 if (last) {
1153                     /*
1154                      * At this point we know two interfaces need a copy
1155                      * of the packet (last + ifp) so we must create a
1156                      * copy to handoff to last.
1157                      */
1158                     m = m_copypacket(m0, M_DONTWAIT);
1159                     if (m == NULL) {
1160                         IFNET_RUNLOCK();
1161                         printf("%s: , m_copypacket failed!\n", __func__);
1162                         bdg_dropped++;
1163                         return m0;      /* the original is still there... */
1164                     }
1165                     IFQ_HANDOFF(last, m, error);
1166                     if (!error)
1167                         BDG_STAT(last, BDG_OUT);
1168                     else
1169                         bdg_dropped++;
1170                 }
1171                 last = ifp;
1172             }
1173         }
1174         IFNET_RUNLOCK();
1175     } else {
1176         if (bridge_ifok(dst, src, real_dst))
1177             last = dst;
1178     }
1179     if (last) {
1180         if (shared) {                   /* need to copy */
1181             m = m_copypacket(m0, M_DONTWAIT);
1182             if (m == NULL) {
1183                 printf("%s: sorry, m_copypacket failed!\n", __func__);
1184                 bdg_dropped++ ;
1185                 return m0;              /* the original is still there... */
1186             }
1187         } else {                        /* consume original */
1188             m = m0, m0 = NULL;
1189         }
1190         IFQ_HANDOFF(last, m, error);
1191         if (!error)
1192             BDG_STAT(last, BDG_OUT);
1193         else
1194             bdg_dropped++;
1195     }
1196
1197     DDB(bdg_fw_ticks += (u_long)(rdtsc() - ticks) ; bdg_fw_count++ ;
1198         if (bdg_fw_count != 0) bdg_fw_avg = bdg_fw_ticks/bdg_fw_count; )
1199     return m0;
1200 #undef EH_RESTORE
1201 }
1202
1203 /*
1204  * initialization of bridge code.
1205  */
1206 static int
1207 bdginit(void)
1208 {
1209     if (bootverbose)
1210             printf("BRIDGE %s loaded\n", bridge_version);
1211
1212     ifp2sc = malloc(BDG_MAX_PORTS * sizeof(struct bdg_softc),
1213                 M_IFADDR, M_WAITOK | M_ZERO );
1214     if (ifp2sc == NULL)
1215         return ENOMEM;
1216
1217     BDG_LOCK_INIT();
1218
1219     n_clusters = 0;
1220     clusters = NULL;
1221     do_bridge = 0;
1222
1223     bzero(&bdg_stats, sizeof(bdg_stats));
1224
1225     bridge_in_ptr = bridge_in;
1226     bdg_forward_ptr = bdg_forward;
1227     bdgtakeifaces_ptr = reconfigure_bridge;
1228
1229     bdgtakeifaces_ptr();                /* XXX does this do anything? */
1230
1231     callout_init(&bdg_callout, NET_CALLOUT_MPSAFE);
1232     bdg_timeout(0);
1233     return 0 ;
1234 }
1235
1236 static void
1237 bdgdestroy(void)
1238 {
1239     bridge_in_ptr = NULL;
1240     bdg_forward_ptr = NULL;
1241     bdgtakeifaces_ptr = NULL;
1242
1243     callout_stop(&bdg_callout);
1244     BDG_LOCK();
1245     bridge_off();
1246
1247     if (ifp2sc) {
1248         free(ifp2sc, M_IFADDR);
1249         ifp2sc = NULL;
1250     }
1251     BDG_LOCK_DESTROY();
1252 }
1253
1254 /*
1255  * initialization code, both for static and dynamic loading.
1256  */
1257 static int
1258 bridge_modevent(module_t mod, int type, void *unused)
1259 {
1260         int err;
1261
1262         switch (type) {
1263         case MOD_LOAD:
1264                 if (BDG_LOADED)
1265                         err = EEXIST;
1266                 else
1267                         err = bdginit();
1268                 break;
1269         case MOD_UNLOAD:
1270                 do_bridge = 0;
1271                 bdgdestroy();
1272                 err = 0;
1273                 break;
1274         default:
1275                 err = EINVAL;
1276                 break;
1277         }
1278         return err;
1279 }
1280
1281 static moduledata_t bridge_mod = {
1282         "bridge",
1283         bridge_modevent,
1284         0
1285 };
1286
1287 DECLARE_MODULE(bridge, bridge_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
1288 MODULE_VERSION(bridge, 1);