sys/net/netisr.c

   1 /*
   2  * Copyright (c) 2003, 2004 Matthew Dillon. All rights reserved.
   3  * Copyright (c) 2003, 2004 Jeffrey M. Hsu.  All rights reserved.
   4  * Copyright (c) 2003 Jonathan Lemon.  All rights reserved.
   5  * Copyright (c) 2003, 2004 The DragonFly Project.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to The DragonFly Project
   8  * by Jonathan Lemon, Jeffrey M. Hsu, and Matthew Dillon.
   9  *
  10  * Jonathan Lemon gave Jeffrey Hsu permission to combine his copyright
  11  * into this one around July 8 2004.
  12  *
  13  * Redistribution and use in source and binary forms, with or without
  14  * modification, are permitted provided that the following conditions
  15  * are met:
  16  * 1. Redistributions of source code must retain the above copyright
  17  *    notice, this list of conditions and the following disclaimer.
  18  * 2. Redistributions in binary form must reproduce the above copyright
  19  *    notice, this list of conditions and the following disclaimer in the
  20  *    documentation and/or other materials provided with the distribution.
  21  * 3. Neither the name of The DragonFly Project nor the names of its
  22  *    contributors may be used to endorse or promote products derived
  23  *    from this software without specific, prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  28  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  29  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  30  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  31  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  33  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  34  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  35  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  36  * SUCH DAMAGE.
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/kernel.h>
  42 #include <sys/malloc.h>
  43 #include <sys/msgport.h>
  44 #include <sys/proc.h>
  45 #include <sys/interrupt.h>
  46 #include <sys/socket.h>
  47 #include <sys/sysctl.h>
  48 #include <sys/socketvar.h>
  49 #include <net/if.h>
  50 #include <net/if_var.h>
  51 #include <net/netisr2.h>
  52 #include <machine/cpufunc.h>
  53 #include <machine/smp.h>
  54
  55 #include <sys/thread2.h>
  56 #include <sys/msgport2.h>
  57 #include <net/netmsg2.h>
  58 #include <sys/mplock2.h>
  59
  60 static void netmsg_service_loop(void *arg);
  61 static void netisr_hashfn0(struct mbuf **mp, int hoff);
  62 static void netisr_nohashck(struct mbuf *, const struct pktinfo *);
  63
  64 struct netmsg_port_registration {
  65         TAILQ_ENTRY(netmsg_port_registration) npr_entry;
  66         lwkt_port_t     npr_port;
  67 };
  68
  69 struct netmsg_rollup {
  70         TAILQ_ENTRY(netmsg_rollup) ru_entry;
  71         netisr_ru_t     ru_func;
  72         int             ru_prio;
  73 };
  74
  75 struct netmsg_barrier {
  76         struct netmsg_base      base;
  77         volatile cpumask_t      *br_cpumask;
  78         volatile uint32_t       br_done;
  79 };
  80
  81 #define NETISR_BR_NOTDONE       0x1
  82 #define NETISR_BR_WAITDONE      0x80000000
  83
  84 struct netisr_barrier {
  85         struct netmsg_barrier   *br_msgs[MAXCPU];
  86         int                     br_isset;
  87 };
  88
  89 void *netlastfunc[MAXCPU];
  90 static struct netisr netisrs[NETISR_MAX];
  91 static TAILQ_HEAD(,netmsg_port_registration) netreglist;
  92 static TAILQ_HEAD(,netmsg_rollup) netrulist;
  93
  94 /* Per-CPU thread to handle any protocol.  */
  95 struct thread *netisr_cpu[MAXCPU];
  96 lwkt_port netisr_afree_rport;
  97 lwkt_port netisr_afree_free_so_rport;
  98 lwkt_port netisr_adone_rport;
  99 lwkt_port netisr_apanic_rport;
 100 lwkt_port netisr_sync_port;
 101
 102 static int (*netmsg_fwd_port_fn)(lwkt_port_t, lwkt_msg_t);
 103
 104 SYSCTL_NODE(_net, OID_AUTO, netisr, CTLFLAG_RW, 0, "netisr");
 105 static int netisr_rollup_limit = 32;
 106 SYSCTL_INT(_net_netisr, OID_AUTO, rollup_limit, CTLFLAG_RW,
 107         &netisr_rollup_limit, 0, "Message to process before rollup");
 108
 109
 110 /*
 111  * netisr_afree_rport replymsg function, only used to handle async
 112  * messages which the sender has abandoned to their fate.
 113  */
 114 static void
 115 netisr_autofree_reply(lwkt_port_t port, lwkt_msg_t msg)
 116 {
 117         kfree(msg, M_LWKTMSG);
 118 }
 119
 120 static void
 121 netisr_autofree_free_so_reply(lwkt_port_t port, lwkt_msg_t msg)
 122 {
 123         sofree(((netmsg_t)msg)->base.nm_so);
 124         kfree(msg, M_LWKTMSG);
 125 }
 126
 127 /*
 128  * We need a custom putport function to handle the case where the
 129  * message target is the current thread's message port.  This case
 130  * can occur when the TCP or UDP stack does a direct callback to NFS and NFS
 131  * then turns around and executes a network operation synchronously.
 132  *
 133  * To prevent deadlocking, we must execute these self-referential messages
 134  * synchronously, effectively turning the message into a glorified direct
 135  * procedure call back into the protocol stack.  The operation must be
 136  * complete on return or we will deadlock, so panic if it isn't.
 137  *
 138  * However, the target function is under no obligation to immediately
 139  * reply the message.  It may forward it elsewhere.
 140  */
 141 static int
 142 netmsg_put_port(lwkt_port_t port, lwkt_msg_t lmsg)
 143 {
 144         netmsg_base_t nmsg = (void *)lmsg;
 145
 146         if ((lmsg->ms_flags & MSGF_SYNC) && port == &curthread->td_msgport) {
 147                 nmsg->nm_dispatch((netmsg_t)nmsg);
 148                 return(EASYNC);
 149         } else {
 150                 return(netmsg_fwd_port_fn(port, lmsg));
 151         }
 152 }
 153
 154 /*
 155  * UNIX DOMAIN sockets still have to run their uipc functions synchronously,
 156  * because they depend on the user proc context for a number of things
 157  * (like creds) which we have not yet incorporated into the message structure.
 158  *
 159  * However, we maintain or message/port abstraction.  Having a special
 160  * synchronous port which runs the commands synchronously gives us the
 161  * ability to serialize operations in one place later on when we start
 162  * removing the BGL.
 163  */
 164 static int
 165 netmsg_sync_putport(lwkt_port_t port, lwkt_msg_t lmsg)
 166 {
 167         netmsg_base_t nmsg = (void *)lmsg;
 168
 169         KKASSERT((lmsg->ms_flags & MSGF_DONE) == 0);
 170
 171         lmsg->ms_target_port = port;    /* required for abort */
 172         nmsg->nm_dispatch((netmsg_t)nmsg);
 173         return(EASYNC);
 174 }
 175
 176 static void
 177 netisr_init(void)
 178 {
 179         int i;
 180
 181         TAILQ_INIT(&netreglist);
 182         TAILQ_INIT(&netrulist);
 183
 184         /*
 185          * Create default per-cpu threads for generic protocol handling.
 186          */
 187         for (i = 0; i < ncpus; ++i) {
 188                 lwkt_create(netmsg_service_loop, NULL, &netisr_cpu[i],
 189                             NULL,
 190                             TDF_NOSTART|TDF_FORCE_SPINPORT|TDF_FIXEDCPU,
 191                             i, "netisr_cpu %d", i);
 192                 netmsg_service_port_init(&netisr_cpu[i]->td_msgport);
 193                 lwkt_schedule(netisr_cpu[i]);
 194         }
 195
 196         /*
 197          * The netisr_afree_rport is a special reply port which automatically
 198          * frees the replied message.  The netisr_adone_rport simply marks
 199          * the message as being done.  The netisr_apanic_rport panics if
 200          * the message is replied to.
 201          */
 202         lwkt_initport_replyonly(&netisr_afree_rport, netisr_autofree_reply);
 203         lwkt_initport_replyonly(&netisr_afree_free_so_rport,
 204                                 netisr_autofree_free_so_reply);
 205         lwkt_initport_replyonly_null(&netisr_adone_rport);
 206         lwkt_initport_panic(&netisr_apanic_rport);
 207
 208         /*
 209          * The netisr_syncport is a special port which executes the message
 210          * synchronously and waits for it if EASYNC is returned.
 211          */
 212         lwkt_initport_putonly(&netisr_sync_port, netmsg_sync_putport);
 213 }
 214
 215 SYSINIT(netisr, SI_SUB_PRE_DRIVERS, SI_ORDER_FIRST, netisr_init, NULL);
 216
 217 /*
 218  * Finish initializing the message port for a netmsg service.  This also
 219  * registers the port for synchronous cleanup operations such as when an
 220  * ifnet is being destroyed.  There is no deregistration API yet.
 221  */
 222 void
 223 netmsg_service_port_init(lwkt_port_t port)
 224 {
 225         struct netmsg_port_registration *reg;
 226
 227         /*
 228          * Override the putport function.  Our custom function checks for
 229          * self-references and executes such commands synchronously.
 230          */
 231         if (netmsg_fwd_port_fn == NULL)
 232                 netmsg_fwd_port_fn = port->mp_putport;
 233         KKASSERT(netmsg_fwd_port_fn == port->mp_putport);
 234         port->mp_putport = netmsg_put_port;
 235
 236         /*
 237          * Keep track of ports using the netmsg API so we can synchronize
 238          * certain operations (such as freeing an ifnet structure) across all
 239          * consumers.
 240          */
 241         reg = kmalloc(sizeof(*reg), M_TEMP, M_WAITOK|M_ZERO);
 242         reg->npr_port = port;
 243         TAILQ_INSERT_TAIL(&netreglist, reg, npr_entry);
 244 }
 245
 246 /*
 247  * This function synchronizes the caller with all netmsg services.  For
 248  * example, if an interface is being removed we must make sure that all
 249  * packets related to that interface complete processing before the structure
 250  * can actually be freed.  This sort of synchronization is an alternative to
 251  * ref-counting the netif, removing the ref counting overhead in favor of
 252  * placing additional overhead in the netif freeing sequence (where it is
 253  * inconsequential).
 254  */
 255 void
 256 netmsg_service_sync(void)
 257 {
 258         struct netmsg_port_registration *reg;
 259         struct netmsg_base smsg;
 260
 261         netmsg_init(&smsg, NULL, &curthread->td_msgport, 0, netmsg_sync_handler);
 262
 263         TAILQ_FOREACH(reg, &netreglist, npr_entry) {
 264                 lwkt_domsg(reg->npr_port, &smsg.lmsg, 0);
 265         }
 266 }
 267
 268 /*
 269  * The netmsg function simply replies the message.  API semantics require
 270  * EASYNC to be returned if the netmsg function disposes of the message.
 271  */
 272 void
 273 netmsg_sync_handler(netmsg_t msg)
 274 {
 275         lwkt_replymsg(&msg->lmsg, 0);
 276 }
 277
 278 /*
 279  * Generic netmsg service loop.  Some protocols may roll their own but all
 280  * must do the basic command dispatch function call done here.
 281  */
 282 static void
 283 netmsg_service_loop(void *arg)
 284 {
 285         struct netmsg_rollup *ru;
 286         netmsg_base_t msg;
 287         thread_t td = curthread;
 288         int limit;
 289
 290         td->td_type = TD_TYPE_NETISR;
 291
 292         while ((msg = lwkt_waitport(&td->td_msgport, 0))) {
 293                 /*
 294                  * Run up to 512 pending netmsgs.
 295                  */
 296                 limit = netisr_rollup_limit;
 297                 do {
 298                         KASSERT(msg->nm_dispatch != NULL,
 299                                 ("netmsg_service isr %d badmsg",
 300                                 msg->lmsg.u.ms_result));
 301                         /*
 302                          * Don't match so_port, if the msg explicitly
 303                          * asks us to ignore its so_port.
 304                          */
 305                         if ((msg->lmsg.ms_flags & MSGF_IGNSOPORT) == 0 &&
 306                             msg->nm_so &&
 307                             msg->nm_so->so_port != &td->td_msgport) {
 308                                 /*
 309                                  * Sockets undergoing connect or disconnect
 310                                  * ops can change ports on us.  Chase the
 311                                  * port.
 312                                  */
 313 #ifdef foo
 314                                 /*
 315                                  * This could be quite common for protocols
 316                                  * which support asynchronous pru_connect,
 317                                  * e.g. TCP, so kprintf socket port chasing
 318                                  * could be too verbose for the console.
 319                                  */
 320                                 kprintf("%s: Warning, port changed so=%p\n",
 321                                         __func__, msg->nm_so);
 322 #endif
 323                                 lwkt_forwardmsg(msg->nm_so->so_port,
 324                                                 &msg->lmsg);
 325                         } else {
 326                                 /*
 327                                  * We are on the correct port, dispatch it.
 328                                  */
 329                                 netlastfunc[mycpuid] = msg->nm_dispatch;
 330                                 msg->nm_dispatch((netmsg_t)msg);
 331                         }
 332                         if (--limit == 0)
 333                                 break;
 334                 } while ((msg = lwkt_getport(&td->td_msgport)) != NULL);
 335
 336                 /*
 337                  * Run all registered rollup functions for this cpu
 338                  * (e.g. tcp_willblock()).
 339                  */
 340                 TAILQ_FOREACH(ru, &netrulist, ru_entry)
 341                         ru->ru_func();
 342         }
 343 }
 344
 345 /*
 346  * Forward a packet to a netisr service function.
 347  *
 348  * If the packet has not been assigned to a protocol thread we call
 349  * the port characterization function to assign it.  The caller must
 350  * clear M_HASH (or not have set it in the first place) if the caller
 351  * wishes the packet to be recharacterized.
 352  */
 353 int
 354 netisr_queue(int num, struct mbuf *m)
 355 {
 356         struct netisr *ni;
 357         struct netmsg_packet *pmsg;
 358         lwkt_port_t port;
 359
 360         KASSERT((num > 0 && num <= NELEM(netisrs)),
 361                 ("Bad isr %d", num));
 362
 363         ni = &netisrs[num];
 364         if (ni->ni_handler == NULL) {
 365                 kprintf("%s: Unregistered isr %d\n", __func__, num);
 366                 m_freem(m);
 367                 return (EIO);
 368         }
 369
 370         /*
 371          * Figure out which protocol thread to send to.  This does not
 372          * have to be perfect but performance will be really good if it
 373          * is correct.  Major protocol inputs such as ip_input() will
 374          * re-characterize the packet as necessary.
 375          */
 376         if ((m->m_flags & M_HASH) == 0) {
 377                 ni->ni_hashfn(&m, 0);
 378                 if (m == NULL)
 379                         return (EIO);
 380                 if ((m->m_flags & M_HASH) == 0) {
 381                         kprintf("%s(%d): packet hash failed\n",
 382                                 __func__, num);
 383                         m_freem(m);
 384                         return (EIO);
 385                 }
 386         }
 387
 388         /*
 389          * Get the protocol port based on the packet hash, initialize
 390          * the netmsg, and send it off.
 391          */
 392         port = netisr_hashport(m->m_pkthdr.hash);
 393         pmsg = &m->m_hdr.mh_netmsg;
 394         netmsg_init(&pmsg->base, NULL, &netisr_apanic_rport,
 395                     0, ni->ni_handler);
 396         pmsg->nm_packet = m;
 397         pmsg->base.lmsg.u.ms_result = num;
 398         lwkt_sendmsg(port, &pmsg->base.lmsg);
 399
 400         return (0);
 401 }
 402
 403 /*
 404  * Run a netisr service function on the packet.
 405  *
 406  * The packet must have been correctly characterized!
 407  */
 408 int
 409 netisr_handle(int num, struct mbuf *m)
 410 {
 411         struct netisr *ni;
 412         struct netmsg_packet *pmsg;
 413         lwkt_port_t port;
 414
 415         /*
 416          * Get the protocol port based on the packet hash
 417          */
 418         KASSERT((m->m_flags & M_HASH), ("packet not characterized"));
 419         port = netisr_hashport(m->m_pkthdr.hash);
 420         KASSERT(&curthread->td_msgport == port, ("wrong msgport"));
 421
 422         KASSERT((num > 0 && num <= NELEM(netisrs)), ("bad isr %d", num));
 423         ni = &netisrs[num];
 424         if (ni->ni_handler == NULL) {
 425                 kprintf("%s: unregistered isr %d\n", __func__, num);
 426                 m_freem(m);
 427                 return EIO;
 428         }
 429
 430         /*
 431          * Initialize the netmsg, and run the handler directly.
 432          */
 433         pmsg = &m->m_hdr.mh_netmsg;
 434         netmsg_init(&pmsg->base, NULL, &netisr_apanic_rport,
 435                     0, ni->ni_handler);
 436         pmsg->nm_packet = m;
 437         pmsg->base.lmsg.u.ms_result = num;
 438         ni->ni_handler((netmsg_t)&pmsg->base);
 439
 440         return 0;
 441 }
 442
 443 /*
 444  * Pre-characterization of a deeper portion of the packet for the
 445  * requested isr.
 446  *
 447  * The base of the ISR type (e.g. IP) that we want to characterize is
 448  * at (hoff) relative to the beginning of the mbuf.  This allows
 449  * e.g. ether_characterize() to not have to adjust the m_data/m_len.
 450  */
 451 void
 452 netisr_characterize(int num, struct mbuf **mp, int hoff)
 453 {
 454         struct netisr *ni;
 455         struct mbuf *m;
 456
 457         /*
 458          * Validation
 459          */
 460         m = *mp;
 461         KKASSERT(m != NULL);
 462
 463         if (num < 0 || num >= NETISR_MAX) {
 464                 if (num == NETISR_MAX) {
 465                         m_sethash(m, 0);
 466                         return;
 467                 }
 468                 panic("Bad isr %d", num);
 469         }
 470
 471         /*
 472          * Valid netisr?
 473          */
 474         ni = &netisrs[num];
 475         if (ni->ni_handler == NULL) {
 476                 kprintf("%s: Unregistered isr %d\n", __func__, num);
 477                 m_freem(m);
 478                 *mp = NULL;
 479         }
 480
 481         /*
 482          * Characterize the packet
 483          */
 484         if ((m->m_flags & M_HASH) == 0) {
 485                 ni->ni_hashfn(mp, hoff);
 486                 m = *mp;
 487                 if (m && (m->m_flags & M_HASH) == 0) {
 488                         kprintf("%s(%d): packet hash failed\n",
 489                                 __func__, num);
 490                 }
 491         }
 492 }
 493
 494 void
 495 netisr_register(int num, netisr_fn_t handler, netisr_hashfn_t hashfn)
 496 {
 497         struct netisr *ni;
 498
 499         KASSERT((num > 0 && num <= NELEM(netisrs)),
 500                 ("netisr_register: bad isr %d", num));
 501         KKASSERT(handler != NULL);
 502
 503         if (hashfn == NULL)
 504                 hashfn = netisr_hashfn0;
 505
 506         ni = &netisrs[num];
 507
 508         ni->ni_handler = handler;
 509         ni->ni_hashck = netisr_nohashck;
 510         ni->ni_hashfn = hashfn;
 511         netmsg_init(&ni->ni_netmsg, NULL, &netisr_adone_rport, 0, NULL);
 512 }
 513
 514 void
 515 netisr_register_hashcheck(int num, netisr_hashck_t hashck)
 516 {
 517         struct netisr *ni;
 518
 519         KASSERT((num > 0 && num <= NELEM(netisrs)),
 520                 ("netisr_register: bad isr %d", num));
 521
 522         ni = &netisrs[num];
 523         ni->ni_hashck = hashck;
 524 }
 525
 526 void
 527 netisr_register_rollup(netisr_ru_t ru_func, int prio)
 528 {
 529         struct netmsg_rollup *new_ru, *ru;
 530
 531         new_ru = kmalloc(sizeof(*new_ru), M_TEMP, M_WAITOK|M_ZERO);
 532         new_ru->ru_func = ru_func;
 533         new_ru->ru_prio = prio;
 534
 535         /*
 536          * Higher priority "rollup" appears first
 537          */
 538         TAILQ_FOREACH(ru, &netrulist, ru_entry) {
 539                 if (ru->ru_prio < new_ru->ru_prio) {
 540                         TAILQ_INSERT_BEFORE(ru, new_ru, ru_entry);
 541                         return;
 542                 }
 543         }
 544         TAILQ_INSERT_TAIL(&netrulist, new_ru, ru_entry);
 545 }
 546
 547 /*
 548  * Return a default protocol control message processing thread port
 549  */
 550 lwkt_port_t
 551 cpu0_ctlport(int cmd __unused, struct sockaddr *sa __unused,
 552     void *extra __unused, int *cpuid)
 553 {
 554         *cpuid = 0;
 555         return netisr_cpuport(*cpuid);
 556 }
 557
 558 /*
 559  * This is a default netisr packet characterization function which
 560  * sets M_HASH.  If a netisr is registered with a NULL hashfn function
 561  * this one is assigned.
 562  *
 563  * This function makes no attempt to validate the packet.
 564  */
 565 static void
 566 netisr_hashfn0(struct mbuf **mp, int hoff __unused)
 567 {
 568
 569         m_sethash(*mp, 0);
 570 }
 571
 572 /*
 573  * schednetisr() is used to call the netisr handler from the appropriate
 574  * netisr thread for polling and other purposes.
 575  *
 576  * This function may be called from a hard interrupt or IPI and must be
 577  * MP SAFE and non-blocking.  We use a fixed per-cpu message instead of
 578  * trying to allocate one.  We must get ourselves onto the target cpu
 579  * to safely check the MSGF_DONE bit on the message but since the message
 580  * will be sent to that cpu anyway this does not add any extra work beyond
 581  * what lwkt_sendmsg() would have already had to do to schedule the target
 582  * thread.
 583  */
 584 static void
 585 schednetisr_remote(void *data)
 586 {
 587         int num = (int)(intptr_t)data;
 588         struct netisr *ni = &netisrs[num];
 589         lwkt_port_t port = &netisr_cpu[0]->td_msgport;
 590         netmsg_base_t pmsg;
 591
 592         pmsg = &netisrs[num].ni_netmsg;
 593         if (pmsg->lmsg.ms_flags & MSGF_DONE) {
 594                 netmsg_init(pmsg, NULL, &netisr_adone_rport, 0, ni->ni_handler);
 595                 pmsg->lmsg.u.ms_result = num;
 596                 lwkt_sendmsg(port, &pmsg->lmsg);
 597         }
 598 }
 599
 600 void
 601 schednetisr(int num)
 602 {
 603         KASSERT((num > 0 && num <= NELEM(netisrs)),
 604                 ("schednetisr: bad isr %d", num));
 605         KKASSERT(netisrs[num].ni_handler != NULL);
 606         if (mycpu->gd_cpuid != 0) {
 607                 lwkt_send_ipiq(globaldata_find(0),
 608                                schednetisr_remote, (void *)(intptr_t)num);
 609         } else {
 610                 crit_enter();
 611                 schednetisr_remote((void *)(intptr_t)num);
 612                 crit_exit();
 613         }
 614 }
 615
 616 static void
 617 netisr_barrier_dispatch(netmsg_t nmsg)
 618 {
 619         struct netmsg_barrier *msg = (struct netmsg_barrier *)nmsg;
 620
 621         ATOMIC_CPUMASK_NANDBIT(*msg->br_cpumask, mycpu->gd_cpuid);
 622         if (CPUMASK_TESTZERO(*msg->br_cpumask))
 623                 wakeup(msg->br_cpumask);
 624
 625         for (;;) {
 626                 uint32_t done = msg->br_done;
 627
 628                 cpu_ccfence();
 629                 if ((done & NETISR_BR_NOTDONE) == 0)
 630                         break;
 631
 632                 tsleep_interlock(&msg->br_done, 0);
 633                 if (atomic_cmpset_int(&msg->br_done,
 634                     done, done | NETISR_BR_WAITDONE))
 635                         tsleep(&msg->br_done, PINTERLOCKED, "nbrdsp", 0);
 636         }
 637
 638         lwkt_replymsg(&nmsg->lmsg, 0);
 639 }
 640
 641 struct netisr_barrier *
 642 netisr_barrier_create(void)
 643 {
 644         struct netisr_barrier *br;
 645
 646         br = kmalloc(sizeof(*br), M_LWKTMSG, M_WAITOK | M_ZERO);
 647         return br;
 648 }
 649
 650 void
 651 netisr_barrier_set(struct netisr_barrier *br)
 652 {
 653         volatile cpumask_t other_cpumask;
 654         int i, cur_cpuid;
 655
 656         ASSERT_IN_NETISR(0);
 657         KKASSERT(!br->br_isset);
 658
 659         other_cpumask = mycpu->gd_other_cpus;
 660         CPUMASK_ANDMASK(other_cpumask, smp_active_mask);
 661         cur_cpuid = mycpuid;
 662
 663         for (i = 0; i < ncpus; ++i) {
 664                 struct netmsg_barrier *msg;
 665
 666                 if (i == cur_cpuid)
 667                         continue;
 668
 669                 msg = kmalloc(sizeof(struct netmsg_barrier),
 670                               M_LWKTMSG, M_WAITOK);
 671
 672                 /*
 673                  * Don't use priority message here; mainly to keep
 674                  * it ordered w/ the previous data packets sent by
 675                  * the caller.
 676                  */
 677                 netmsg_init(&msg->base, NULL, &netisr_afree_rport, 0,
 678                             netisr_barrier_dispatch);
 679                 msg->br_cpumask = &other_cpumask;
 680                 msg->br_done = NETISR_BR_NOTDONE;
 681
 682                 KKASSERT(br->br_msgs[i] == NULL);
 683                 br->br_msgs[i] = msg;
 684         }
 685
 686         for (i = 0; i < ncpus; ++i) {
 687                 if (i == cur_cpuid)
 688                         continue;
 689                 lwkt_sendmsg(netisr_cpuport(i), &br->br_msgs[i]->base.lmsg);
 690         }
 691
 692         while (CPUMASK_TESTNZERO(other_cpumask)) {
 693                 tsleep_interlock(&other_cpumask, 0);
 694                 if (CPUMASK_TESTNZERO(other_cpumask))
 695                         tsleep(&other_cpumask, PINTERLOCKED, "nbrset", 0);
 696         }
 697         br->br_isset = 1;
 698 }
 699
 700 void
 701 netisr_barrier_rem(struct netisr_barrier *br)
 702 {
 703         int i, cur_cpuid;
 704
 705         ASSERT_IN_NETISR(0);
 706         KKASSERT(br->br_isset);
 707
 708         cur_cpuid = mycpuid;
 709         for (i = 0; i < ncpus; ++i) {
 710                 struct netmsg_barrier *msg = br->br_msgs[i];
 711                 uint32_t done;
 712
 713                 msg = br->br_msgs[i];
 714                 br->br_msgs[i] = NULL;
 715
 716                 if (i == cur_cpuid)
 717                         continue;
 718
 719                 done = atomic_swap_int(&msg->br_done, 0);
 720                 if (done & NETISR_BR_WAITDONE)
 721                         wakeup(&msg->br_done);
 722         }
 723         br->br_isset = 0;
 724 }
 725
 726 static void
 727 netisr_nohashck(struct mbuf *m, const struct pktinfo *pi __unused)
 728 {
 729         m->m_flags &= ~M_HASH;
 730 }
 731
 732 void
 733 netisr_hashcheck(int num, struct mbuf *m, const struct pktinfo *pi)
 734 {
 735         struct netisr *ni;
 736
 737         if (num < 0 || num >= NETISR_MAX)
 738                 panic("Bad isr %d", num);
 739
 740         /*
 741          * Valid netisr?
 742          */
 743         ni = &netisrs[num];
 744         if (ni->ni_handler == NULL)
 745                 panic("Unregistered isr %d", num);
 746
 747         ni->ni_hashck(m, pi);
 748 }