tools/tools/netrate/pktgen/pktgen.c

   1 /*
   2  * Copyright (c) 2012 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Sepherosa Ziehau <sepherosa@gmail.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/tools/tools/netrate/pktgen/pktgen.c,v 1.4 2008/04/02 14:18:55 sephe Exp $
  35  */
  36
  37 #define _IP_VHL
  38
  39 #include <sys/param.h>
  40 #include <sys/conf.h>
  41 #include <sys/device.h>
  42 #include <sys/in_cksum.h>
  43 #include <sys/kernel.h>
  44 #include <sys/malloc.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/proc.h>
  47 #include <sys/priv.h>
  48 #include <sys/queue.h>
  49 #include <sys/socket.h>
  50 #include <sys/systm.h>
  51 #include <sys/serialize.h>
  52
  53 #include <net/if.h>
  54 #include <net/if_dl.h>
  55 #include <net/if_var.h>
  56 #include <net/ifq_var.h>
  57 #include <net/ethernet.h>
  58 #include <net/netmsg2.h>
  59 #include <net/netisr2.h>
  60
  61 #include <netinet/in.h>
  62 #include <netinet/in_pcb.h>
  63 #include <netinet/ip.h>
  64 #include <netinet/udp_var.h>
  65
  66 #include "pktgen.h"
  67
  68 #define CDEV_NAME       "pktg"
  69
  70 #define PKTGEN_BUFSZ    2048
  71
  72 #ifndef PKTGEN_DEVCNT
  73 #define PKTGEN_DEVCNT   4
  74 #endif
  75
  76 struct pktgen;
  77
  78 struct netmsg_pktgen {
  79         struct netmsg_base      np_base;
  80         struct pktgen           *np_pktg;
  81         struct ifaltq_subque    *np_ifsq;
  82 };
  83
  84 struct pktgen_buf {
  85         struct netmsg_base      pb_nmsg;        /* MUST BE THE FIRST */
  86         void                    *pb_buf;
  87         volatile int            pb_done;
  88         int                     pb_inuse;
  89         struct ifnet            *pb_ifp;
  90         struct ifaltq_subque    *pb_ifsq;
  91         int                     pb_len;
  92         int                     pb_cpuid;
  93         struct pktgen           *pb_pktg;
  94         LIST_ENTRY(pktgen_buf)  pb_link;
  95 };
  96
  97 struct pktgen_pcpu {
  98         struct callout          pktg_stop;
  99         LIST_HEAD(, pktgen_buf) pktg_buflist;
 100 };
 101
 102 struct pktgen {
 103         uint32_t                pktg_flags;     /* PKTG_F_ */
 104         int                     pktg_refcnt;
 105
 106         int                     pktg_duration;
 107
 108         int                     pktg_datalen;
 109         struct ifnet            *pktg_ifp;
 110
 111         int                     pktg_pktenq;
 112
 113         struct sockaddr_in      pktg_src;
 114         int                     pktg_ndst;
 115         struct sockaddr_in      *pktg_dst;
 116         uint8_t                 pktg_dst_lladdr[ETHER_ADDR_LEN];
 117
 118         struct pktgen_pcpu      pktg_pcpu[MAXCPU];
 119 };
 120
 121 #define PKTG_F_CONFIG           0x1
 122 #define PKTG_F_RUNNING          0x4
 123 #define PKTG_F_SWITCH_SRCDST    0x8
 124
 125 static int              pktgen_modevent(module_t, int, void *);
 126
 127 static void             pktgen_buf_free(void *);
 128 static void             pktgen_buf_ref(void *);
 129 static void             pktgen_buf_send(netmsg_t);
 130
 131 static int              pktgen_config(struct pktgen *,
 132                             const struct pktgen_conf *);
 133 static int              pktgen_start(struct pktgen *, int);
 134 static void             pktgen_free(struct pktgen *);
 135 static void             pktgen_ref(struct pktgen *);
 136 static void             pktgen_pcpu_stop_cb(void *);
 137 static void             pktgen_mbuf(struct pktgen_buf *, struct mbuf *);
 138 static void             pktgen_start_ifsq(struct pktgen *,
 139                             struct ifaltq_subque *);
 140 static void             pktgen_start_ifsq_handler(netmsg_t);
 141
 142 static d_open_t         pktgen_open;
 143 static d_close_t        pktgen_close;
 144 static d_ioctl_t        pktgen_ioctl;
 145
 146 static struct dev_ops   pktgen_ops = {
 147         { CDEV_NAME, 0, D_MPSAFE },
 148         .d_open =       pktgen_open,
 149         .d_close =      pktgen_close,
 150         .d_ioctl =      pktgen_ioctl,
 151 };
 152
 153 static volatile int             pktgen_refcnt;
 154 static struct lwkt_token pktgen_tok = LWKT_TOKEN_INITIALIZER(pktgen_token);
 155
 156 MALLOC_DECLARE(M_PKTGEN);
 157 MALLOC_DEFINE(M_PKTGEN, CDEV_NAME, "Packet generator");
 158
 159 DEV_MODULE(pktgen, pktgen_modevent, NULL);
 160
 161 static int
 162 pktgen_modevent(module_t mod, int type, void *data)
 163 {
 164         int error = 0, i;
 165
 166         switch (type) {
 167         case MOD_LOAD:
 168                 for (i = 0; i < PKTGEN_DEVCNT; ++i) {
 169                         make_dev(&pktgen_ops, 0, UID_ROOT, GID_WHEEL, 0600,
 170                             CDEV_NAME"%d", i);
 171                 }
 172                 break;
 173
 174         case MOD_UNLOAD:
 175                 if (pktgen_refcnt > 0)
 176                         return EBUSY;
 177                 dev_ops_remove_all(&pktgen_ops);
 178                 break;
 179
 180         default:
 181                 error = EOPNOTSUPP;
 182                 break;
 183         }
 184         return error;
 185 }
 186
 187 static int
 188 pktgen_open(struct dev_open_args *ap)
 189 {
 190         cdev_t dev = ap->a_head.a_dev;
 191         struct pktgen *pktg;
 192         int error, i;
 193
 194         error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
 195         if (error)
 196                 return error;
 197
 198         lwkt_gettoken(&pktgen_tok);
 199
 200         if (dev->si_drv1 != NULL) {
 201                 lwkt_reltoken(&pktgen_tok);
 202                 return EBUSY;
 203         }
 204
 205         pktg = kmalloc(sizeof(*pktg), M_PKTGEN, M_ZERO | M_WAITOK);
 206         for (i = 0; i < ncpus; ++i) {
 207                 struct pktgen_pcpu *p = &pktg->pktg_pcpu[i];
 208
 209                 callout_init_mp(&p->pktg_stop);
 210                 LIST_INIT(&p->pktg_buflist);
 211         }
 212
 213         dev->si_drv1 = pktg;
 214         pktg->pktg_refcnt = 1;
 215
 216         atomic_add_int(&pktgen_refcnt, 1);
 217
 218         lwkt_reltoken(&pktgen_tok);
 219         return 0;
 220 }
 221
 222 static int
 223 pktgen_close(struct dev_close_args *ap)
 224 {
 225         cdev_t dev = ap->a_head.a_dev;
 226         struct pktgen *pktg = dev->si_drv1;
 227
 228         lwkt_gettoken(&pktgen_tok);
 229         dev->si_drv1 = NULL;
 230         lwkt_reltoken(&pktgen_tok);
 231
 232         pktgen_free(pktg);
 233
 234         return 0;
 235 }
 236
 237 static int
 238 pktgen_ioctl(struct dev_ioctl_args *ap __unused)
 239 {
 240         cdev_t dev = ap->a_head.a_dev;
 241         caddr_t data = ap->a_data;
 242         struct pktgen *pktg = dev->si_drv1;
 243         int error;
 244
 245         lwkt_gettoken(&pktgen_tok);
 246
 247         switch (ap->a_cmd) {
 248         case PKTGENSTART:
 249                 error = pktgen_start(pktg, 0);
 250                 break;
 251
 252         case PKTGENMQSTART:
 253                 error = pktgen_start(pktg, 1);
 254                 break;
 255
 256         case PKTGENSCONF:
 257                 error = pktgen_config(pktg, (const struct pktgen_conf *)data);
 258                 break;
 259
 260         default:
 261                 error = EOPNOTSUPP;
 262                 break;
 263         }
 264
 265         lwkt_reltoken(&pktgen_tok);
 266         return error;
 267 }
 268
 269 static int
 270 pktgen_config(struct pktgen *pktg, const struct pktgen_conf *conf)
 271 {
 272         const struct sockaddr_in *sin;
 273         struct sockaddr_in *dst = NULL;
 274         const struct sockaddr *sa;
 275         struct ifnet *ifp;
 276         size_t dst_size;
 277         int i, error, pktenq;
 278
 279         if (pktg->pktg_flags & (PKTG_F_RUNNING | PKTG_F_CONFIG))
 280                 return EBUSY;
 281
 282         if (conf->pc_datalen <= 0 ||
 283             conf->pc_datalen > ETHERMTU - sizeof(struct udpiphdr))
 284                 return EINVAL;
 285         if (conf->pc_duration <= 0)
 286                 return EINVAL;
 287
 288         sin = &conf->pc_src;
 289         if (sin->sin_family != AF_INET)
 290                 return EPROTONOSUPPORT;
 291         if (sin->sin_port == 0)
 292                 return EINVAL;
 293
 294         if (conf->pc_ndst <= 0)
 295                 return EINVAL;
 296         dst_size = conf->pc_ndst * sizeof(struct sockaddr_in);
 297
 298         dst = kmalloc(dst_size, M_PKTGEN, M_WAITOK | M_NULLOK);
 299         if (dst == NULL)
 300                 return ENOMEM;
 301
 302         error = copyin(conf->pc_dst, dst, dst_size);
 303         if (error)
 304                 goto failed;
 305
 306         for (i = 0; i < conf->pc_ndst; ++i) {
 307                 sin = &dst[i];
 308                 if (sin->sin_family != AF_INET) {
 309                         error = EPROTONOSUPPORT;
 310                         goto failed;
 311                 }
 312                 if (sin->sin_port == 0) {
 313                         error = EINVAL;
 314                         goto failed;
 315                 }
 316         }
 317
 318         ifp = ifunit(conf->pc_ifname);
 319         if (ifp == NULL) {
 320                 error = ENXIO;
 321                 goto failed;
 322         }
 323
 324         pktenq = conf->pc_pktenq;
 325         if (pktenq < 0 || pktenq > ifp->if_snd.altq_maxlen) {
 326                 error = ENOBUFS;
 327                 goto failed;
 328         } else if (pktenq == 0) {
 329                 pktenq = (ifp->if_snd.altq_maxlen * 3) / 4;
 330         }
 331
 332         sa = &conf->pc_dst_lladdr;
 333         if (sa->sa_family != AF_LINK) {
 334                 error = EPROTONOSUPPORT;
 335                 goto failed;
 336         }
 337         if (sa->sa_len != ETHER_ADDR_LEN) {
 338                 error = EPROTONOSUPPORT;
 339                 goto failed;
 340         }
 341         if (ETHER_IS_MULTICAST(sa->sa_data) ||
 342             bcmp(sa->sa_data, ifp->if_broadcastaddr, ifp->if_addrlen) == 0) {
 343                 error = EADDRNOTAVAIL;
 344                 goto failed;
 345         }
 346
 347         /*
 348          * Accept the config
 349          */
 350         pktg->pktg_flags |= PKTG_F_CONFIG;
 351
 352         if (conf->pc_flags & PKTGEN_FLAG_SWITCH_SRCDST)
 353                 pktg->pktg_flags |= PKTG_F_SWITCH_SRCDST;
 354         pktg->pktg_duration = conf->pc_duration;
 355         pktg->pktg_datalen = conf->pc_datalen;
 356         pktg->pktg_pktenq = pktenq;
 357         pktg->pktg_ifp = ifp;
 358         pktg->pktg_src = conf->pc_src;
 359         pktg->pktg_ndst = conf->pc_ndst;
 360         KKASSERT(pktg->pktg_dst == NULL);
 361         pktg->pktg_dst = dst;
 362         bcopy(sa->sa_data, pktg->pktg_dst_lladdr, ETHER_ADDR_LEN);
 363
 364         return 0;
 365
 366 failed:
 367         if (dst != NULL)
 368                 kfree(dst, M_PKTGEN);
 369         return error;
 370 }
 371
 372 static void
 373 pktgen_start_ifsq(struct pktgen *pktg, struct ifaltq_subque *ifsq)
 374 {
 375         struct netmsg_pktgen *np;
 376
 377         np = kmalloc(sizeof(*np), M_LWKTMSG, M_WAITOK);
 378         netmsg_init(&np->np_base, NULL, &netisr_afree_rport, 0,
 379             pktgen_start_ifsq_handler);
 380         np->np_pktg = pktg;
 381         np->np_ifsq = ifsq;
 382
 383         lwkt_sendmsg(netisr_cpuport(ifsq_get_cpuid(ifsq)), &np->np_base.lmsg);
 384 }
 385
 386 static int
 387 pktgen_start(struct pktgen *pktg, int mq)
 388 {
 389         struct ifaltq *ifq;
 390
 391         if ((pktg->pktg_flags & PKTG_F_CONFIG) == 0)
 392                 return EINVAL;
 393         if (pktg->pktg_flags & PKTG_F_RUNNING)
 394                 return EBUSY;
 395         pktg->pktg_flags |= PKTG_F_RUNNING;
 396
 397         ifq = &pktg->pktg_ifp->if_snd;
 398         if (!mq) {
 399                 pktgen_ref(pktg);
 400                 pktgen_start_ifsq(pktg, ifq_get_subq_default(ifq));
 401         } else {
 402                 int i;
 403
 404                 for (i = 0; i < ifq->altq_subq_cnt; ++i)
 405                         pktgen_ref(pktg);
 406                 for (i = 0; i < ifq->altq_subq_cnt; ++i)
 407                         pktgen_start_ifsq(pktg, ifq_get_subq(ifq, i));
 408         }
 409         return 0;
 410 }
 411
 412 static void
 413 pktgen_start_ifsq_handler(netmsg_t nmsg)
 414 {
 415         struct netmsg_pktgen *np = (struct netmsg_pktgen *)nmsg;
 416         struct pktgen *pktg = np->np_pktg;
 417         struct ifaltq_subque *ifsq = np->np_ifsq;
 418
 419         struct mbuf *m, *head = NULL, **next;
 420         struct ifnet *ifp;
 421         struct pktgen_pcpu *p;
 422         int cpuid, i, alloc_cnt, keep_cnt;
 423
 424         u_short ulen, psum;
 425         int len, ip_len;
 426
 427         /* Reply ASAP */
 428         lwkt_replymsg(&np->np_base.lmsg, 0);
 429
 430         ifp = pktg->pktg_ifp;
 431
 432         cpuid = ifsq_get_cpuid(ifsq);
 433         KKASSERT(cpuid == mycpuid);
 434
 435         p = &pktg->pktg_pcpu[cpuid];
 436
 437         keep_cnt = pktg->pktg_pktenq;
 438         alloc_cnt = keep_cnt * 2;
 439
 440         /*
 441          * Prefault enough mbuf into mbuf objcache
 442          */
 443         next = &head;
 444         for (i = 0; i < alloc_cnt; ++i) {
 445                 MGETHDR(m, MB_WAIT, MT_DATA);
 446                 *next = m;
 447                 next = &m->m_nextpkt;
 448         }
 449
 450         for (i = 0; i < alloc_cnt - keep_cnt; ++i) {
 451                 m = head;
 452                 head = m->m_nextpkt;
 453                 m->m_nextpkt = NULL;
 454                 m_freem(m);
 455         }
 456         KKASSERT(head != NULL);
 457
 458         /*
 459          * Setup the packets' data
 460          */
 461         ip_len = pktg->pktg_datalen + sizeof(struct udpiphdr);
 462         len = ip_len + ETHER_HDR_LEN;
 463
 464         psum = htons((u_short)pktg->pktg_datalen + sizeof(struct udphdr) +
 465             IPPROTO_UDP);
 466         ulen = htons(pktg->pktg_datalen + sizeof(struct udphdr));
 467
 468         m = head;
 469         i = 0;
 470         while (m != NULL) {
 471                 struct mbuf *nextm;
 472                 const struct sockaddr_in *dst;
 473                 struct pktgen_buf *pb;
 474                 struct ip *ip;
 475                 struct udpiphdr *ui;
 476                 struct ether_header *eh;
 477
 478                 pktgen_ref(pktg);
 479
 480                 pb = kmalloc(sizeof(*pb), M_PKTGEN, M_WAITOK | M_ZERO);
 481                 pb->pb_ifp = ifp;
 482                 pb->pb_ifsq = ifsq;
 483                 pb->pb_inuse = 1;
 484                 pb->pb_buf = kmalloc(PKTGEN_BUFSZ, M_PKTGEN, M_WAITOK);
 485                 pb->pb_len = len;
 486                 pb->pb_cpuid = cpuid;
 487                 pb->pb_pktg = pktg;
 488                 netmsg_init(&pb->pb_nmsg, NULL, &netisr_adone_rport, 0,
 489                     pktgen_buf_send);
 490                 LIST_INSERT_HEAD(&p->pktg_buflist, pb, pb_link);
 491
 492                 dst = &pktg->pktg_dst[i % pktg->pktg_ndst];
 493                 ++i;
 494
 495                 m->m_ext.ext_arg = pb;
 496                 m->m_ext.ext_buf = pb->pb_buf;
 497                 m->m_ext.ext_free = pktgen_buf_free;
 498                 m->m_ext.ext_ref = pktgen_buf_ref;
 499                 m->m_ext.ext_size = PKTGEN_BUFSZ;
 500
 501                 m->m_data = m->m_ext.ext_buf;
 502                 m->m_flags |= M_EXT;
 503                 m->m_len = m->m_pkthdr.len = len;
 504
 505                 m->m_data += ETHER_HDR_LEN;
 506                 m->m_len -= ETHER_HDR_LEN;
 507                 m->m_pkthdr.len -= ETHER_HDR_LEN;
 508
 509                 ui = mtod(m, struct udpiphdr *);
 510                 ui->ui_pr = IPPROTO_UDP;
 511                 if (pktg->pktg_flags & PKTG_F_SWITCH_SRCDST) {
 512                         ui->ui_src.s_addr = dst->sin_addr.s_addr;
 513                         ui->ui_dst.s_addr = pktg->pktg_src.sin_addr.s_addr;
 514                         ui->ui_sport = dst->sin_port;
 515                         ui->ui_dport = pktg->pktg_src.sin_port;
 516                 } else {
 517                         ui->ui_src.s_addr = pktg->pktg_src.sin_addr.s_addr;
 518                         ui->ui_dst.s_addr = dst->sin_addr.s_addr;
 519                         ui->ui_sport = pktg->pktg_src.sin_port;
 520                         ui->ui_dport = dst->sin_port;
 521                 }
 522                 ui->ui_ulen = ulen;
 523                 ui->ui_sum = in_pseudo(ui->ui_src.s_addr, ui->ui_dst.s_addr,
 524                     psum);
 525                 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
 526
 527                 ip = (struct ip *)ui;
 528                 ip->ip_len = ip_len;
 529                 ip->ip_ttl = 64;        /* XXX */
 530                 ip->ip_tos = 0;         /* XXX */
 531                 ip->ip_vhl = IP_VHL_BORING;
 532                 ip->ip_off = 0;
 533                 ip->ip_sum = 0;
 534                 ip->ip_id = ip_newid();
 535
 536                 in_delayed_cksum(m);
 537
 538                 ip->ip_len = htons(ip->ip_len);
 539                 ip->ip_sum = in_cksum_hdr(ip);
 540
 541                 m->m_data -= ETHER_HDR_LEN;
 542                 m->m_len += ETHER_HDR_LEN;
 543                 m->m_pkthdr.len += ETHER_HDR_LEN;
 544
 545                 eh = mtod(m, struct ether_header *);
 546                 bcopy(pktg->pktg_dst_lladdr, eh->ether_dhost, ETHER_ADDR_LEN);
 547                 bcopy(IF_LLADDR(ifp), eh->ether_shost, ETHER_ADDR_LEN);
 548                 eh->ether_type = htons(ETHERTYPE_IP);
 549
 550                 nextm = m->m_nextpkt;
 551                 m->m_nextpkt = NULL;
 552
 553                 ifq_dispatch(ifp, m, NULL);
 554
 555                 m = nextm;
 556         }
 557
 558         callout_reset(&p->pktg_stop, pktg->pktg_duration * hz,
 559             pktgen_pcpu_stop_cb, p);
 560
 561         pktgen_free(pktg);
 562 }
 563
 564 static void
 565 pktgen_mbuf(struct pktgen_buf *pb, struct mbuf *m)
 566 {
 567         m->m_ext.ext_arg = pb;
 568         m->m_ext.ext_buf = pb->pb_buf;
 569         m->m_ext.ext_free = pktgen_buf_free;
 570         m->m_ext.ext_ref = pktgen_buf_ref;
 571         m->m_ext.ext_size = PKTGEN_BUFSZ;
 572
 573         m->m_data = m->m_ext.ext_buf;
 574         m->m_flags |= M_EXT;
 575         m->m_len = m->m_pkthdr.len = pb->pb_len;
 576 }
 577
 578 static void
 579 pktgen_buf_send(netmsg_t msg)
 580 {
 581         struct pktgen_buf *pb = (struct pktgen_buf *)msg;
 582         struct mbuf *m;
 583
 584         KKASSERT(&curthread->td_msgport == netisr_cpuport(pb->pb_cpuid));
 585
 586         crit_enter();
 587         lwkt_replymsg(&pb->pb_nmsg.lmsg, 0);
 588         crit_exit();
 589
 590         MGETHDR(m, MB_WAIT, MT_DATA);
 591         pktgen_mbuf(pb, m);
 592         ifq_dispatch(pb->pb_ifp, m, NULL);
 593 }
 594
 595 static void
 596 pktgen_buf_free(void *arg)
 597 {
 598         struct pktgen_buf *pb = arg;
 599         struct mbuf *m;
 600
 601         KKASSERT(pb->pb_inuse > 0);
 602         if (pb->pb_done) {
 603                 if (atomic_fetchadd_int(&pb->pb_inuse, -1) == 1) {
 604                         struct pktgen *pktg;
 605
 606                         pktg = pb->pb_pktg;
 607                         crit_enter();
 608                         LIST_REMOVE(pb, pb_link);
 609                         crit_exit();
 610                         kfree(pb->pb_buf, M_PKTGEN);
 611                         kfree(pb, M_PKTGEN);
 612
 613                         pktgen_free(pktg);
 614                 }
 615                 return;
 616         }
 617
 618         if (&curthread->td_msgport != netisr_cpuport(pb->pb_cpuid)) {
 619                 KKASSERT(pb->pb_cpuid == mycpuid);
 620                 crit_enter();
 621                 KKASSERT(pb->pb_nmsg.lmsg.ms_flags & MSGF_DONE);
 622                 lwkt_sendmsg(netisr_cpuport(pb->pb_cpuid), &pb->pb_nmsg.lmsg);
 623                 crit_exit();
 624                 return;
 625         }
 626
 627         MGETHDR(m, MB_WAIT, MT_DATA);
 628         pktgen_mbuf(pb, m);
 629         ifsq_enqueue(pb->pb_ifsq, m, NULL);
 630 }
 631
 632 static void
 633 pktgen_buf_ref(void *arg)
 634 {
 635         struct pktgen_buf *pb = arg;
 636
 637         panic("%s should never be called\n", __func__);
 638
 639         KKASSERT(pb->pb_inuse > 0);
 640         atomic_add_int(&pb->pb_inuse, 1);
 641 }
 642
 643 static void
 644 pktgen_free(struct pktgen *pktg)
 645 {
 646         KKASSERT(pktg->pktg_refcnt > 0);
 647         if (atomic_fetchadd_int(&pktg->pktg_refcnt, -1) == 1) {
 648                 int i;
 649
 650                 if (pktg->pktg_dst != NULL)
 651                         kfree(pktg->pktg_dst, M_PKTGEN);
 652
 653                 for (i = 0; i < ncpus; ++i)
 654                         KKASSERT(LIST_EMPTY(&pktg->pktg_pcpu[i].pktg_buflist));
 655                 kfree(pktg, M_PKTGEN);
 656         }
 657
 658         KKASSERT(pktgen_refcnt > 0);
 659         atomic_subtract_int(&pktgen_refcnt, 1);
 660 }
 661
 662 static void
 663 pktgen_pcpu_stop_cb(void *arg)
 664 {
 665         struct pktgen_pcpu *p = arg;
 666         struct pktgen_buf *pb;
 667
 668         crit_enter();
 669         LIST_FOREACH(pb, &p->pktg_buflist, pb_link)
 670                 pb->pb_done = 1;
 671         crit_exit();
 672 }
 673
 674 static void
 675 pktgen_ref(struct pktgen *pktg)
 676 {
 677         atomic_add_int(&pktg->pktg_refcnt, 1);
 678         atomic_add_int(&pktgen_refcnt, 1);
 679 }