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