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