2 * Copyright (c) 2008 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Sepherosa Ziehau <sepherosa@gmail.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
34 * $DragonFly: src/tools/tools/netrate/pktgen/pktgen.c,v 1.4 2008/04/02 14:18:55 sephe Exp $
39 #include <sys/param.h>
41 #include <sys/device.h>
42 #include <sys/in_cksum.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h>
48 #include <sys/socket.h>
49 #include <sys/systm.h>
50 #include <sys/serialize.h>
53 #include <net/if_dl.h>
54 #include <net/if_var.h>
55 #include <net/ifq_var.h>
56 #include <net/ethernet.h>
58 #include <netinet/in.h>
59 #include <netinet/ip.h>
60 #include <netinet/udp_var.h>
64 #define CDEV_NAME "pktg"
65 #define CDEV_MAJOR 151
68 uint32_t pktg_flags; /* PKTG_F_ */
72 uint64_t pktg_err_cnt;
73 struct timeval pktg_start;
74 struct timeval pktg_end;
76 struct callout pktg_stop;
79 void (*pktg_thread)(void *);
83 struct ifnet *pktg_ifp;
85 in_addr_t pktg_saddr; /* host byte order */
86 in_addr_t pktg_daddr; /* host byte order */
87 u_short pktg_sport; /* host byte order */
88 u_short pktg_dport; /* host byte order */
95 uint8_t pktg_dst_lladdr[ETHER_ADDR_LEN];
98 #define PKTG_F_CONFIG 0x1
99 #define PKTG_F_STOP 0x2
100 #define PKTG_F_RUNNING 0x4
102 static int pktgen_modevent(module_t, int, void *);
103 static int pktgen_config(struct pktgen *,
104 const struct pktgen_conf *);
105 static int pktgen_start(struct pktgen *, int);
106 static void pktgen_thread_exit(struct pktgen *, uint64_t, uint64_t);
107 static void pktgen_stop_cb(void *);
108 static void pktgen_udp_thread(void *);
109 static void pktgen_udp_thread1(void *);
111 static d_open_t pktgen_open;
112 static d_close_t pktgen_close;
113 static d_ioctl_t pktgen_ioctl;
115 static struct dev_ops pktgen_ops = {
116 { CDEV_NAME, CDEV_MAJOR, 0 },
117 .d_open = pktgen_open,
118 .d_close = pktgen_close,
119 .d_ioctl = pktgen_ioctl,
122 static int pktgen_refcnt;
124 MALLOC_DECLARE(M_PKTGEN);
125 MALLOC_DEFINE(M_PKTGEN, CDEV_NAME, "Packet generator");
127 DEV_MODULE(pktgen, pktgen_modevent, NULL);
130 pktgen_modevent(module_t mod, int type, void *data)
136 make_dev(&pktgen_ops, 0, UID_ROOT, GID_WHEEL, 0600,
141 if (pktgen_refcnt > 0)
143 dev_ops_remove_all(&pktgen_ops);
154 pktgen_open(struct dev_open_args *ap)
156 cdev_t dev = ap->a_head.a_dev;
160 error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0);
166 if (dev->si_drv1 != NULL) {
171 pktg = kmalloc(sizeof(*pktg), M_PKTGEN, M_ZERO | M_WAITOK);
172 callout_init(&pktg->pktg_stop);
175 pktg->pktg_refcnt = 1;
184 pktgen_close(struct dev_close_args *ap)
186 cdev_t dev = ap->a_head.a_dev;
187 struct pktgen *pktg = dev->si_drv1;
191 KKASSERT(pktg->pktg_refcnt > 0);
192 if (--pktg->pktg_refcnt == 0)
193 kfree(pktg, M_PKTGEN);
196 KKASSERT(pktgen_refcnt > 0);
204 pktgen_ioctl(struct dev_ioctl_args *ap __unused)
206 cdev_t dev = ap->a_head.a_dev;
207 caddr_t data = ap->a_data;
208 struct pktgen *pktg = dev->si_drv1;
215 error = pktgen_start(pktg, minor(dev));
219 error = pktgen_config(pktg, (const struct pktgen_conf *)data);
232 pktgen_config(struct pktgen *pktg, const struct pktgen_conf *conf)
234 const struct sockaddr_in *sin;
235 const struct sockaddr *sa;
237 int yield, nsaddr, ndaddr, nsport, ndport, thread1;
239 if (pktg->pktg_flags & PKTG_F_RUNNING)
242 if (conf->pc_cpuid < 0 || conf->pc_cpuid >= ncpus)
244 if (conf->pc_datalen <= 0)
246 if (conf->pc_duration <= 0)
249 yield = conf->pc_yield;
251 yield = PKTGEN_YIELD_DEFAULT;
253 if (conf->pc_nsaddr <= 0 && conf->pc_ndaddr <= 0 &&
254 conf->pc_nsport <= 0 && conf->pc_ndport <= 0)
259 nsaddr = conf->pc_nsaddr;
262 ndaddr = conf->pc_ndaddr;
266 nsport = conf->pc_nsport;
269 ndport = conf->pc_ndport;
273 ifp = ifunit(conf->pc_ifname);
277 sa = &conf->pc_dst_lladdr;
278 if (sa->sa_family != AF_LINK)
279 return EPROTONOSUPPORT;
280 if (sa->sa_len != ETHER_ADDR_LEN)
281 return EPROTONOSUPPORT;
282 if (ETHER_IS_MULTICAST(sa->sa_data) ||
283 bcmp(sa->sa_data, ifp->if_broadcastaddr, ifp->if_addrlen) == 0)
284 return EADDRNOTAVAIL;
287 if (sin->sin_family != AF_INET)
288 return EPROTONOSUPPORT;
289 if (sin->sin_port == 0)
293 if (sin->sin_family != AF_INET)
294 return EPROTONOSUPPORT;
295 if (sin->sin_port == 0)
298 /* Accept the config */
299 pktg->pktg_flags |= PKTG_F_CONFIG;
303 pktg->pktg_duration = conf->pc_duration;
304 pktg->pktg_cpuid = conf->pc_cpuid;
305 pktg->pktg_ifp = ifp;
306 pktg->pktg_datalen = conf->pc_datalen;
307 pktg->pktg_yield = yield;
308 bcopy(sa->sa_data, pktg->pktg_dst_lladdr, ETHER_ADDR_LEN);
310 pktg->pktg_saddr = ntohl(conf->pc_src.sin_addr.s_addr);
311 pktg->pktg_daddr = ntohl(conf->pc_dst.sin_addr.s_addr);
312 pktg->pktg_nsaddr = nsaddr;
313 pktg->pktg_ndaddr = ndaddr;
315 pktg->pktg_sport = ntohs(conf->pc_src.sin_port);
316 pktg->pktg_dport = ntohs(conf->pc_dst.sin_port);
317 pktg->pktg_nsport = nsport;
318 pktg->pktg_ndport = ndport;
320 pktg->pktg_thread = thread1 ? pktgen_udp_thread1 : pktgen_udp_thread;
326 pktgen_start(struct pktgen *pktg, int m)
328 if ((pktg->pktg_flags & PKTG_F_CONFIG) == 0)
330 if (pktg->pktg_flags & PKTG_F_RUNNING)
333 pktg->pktg_flags |= PKTG_F_RUNNING;
335 lwkt_create(pktg->pktg_thread, pktg, NULL, NULL, 0,
336 pktg->pktg_cpuid, "pktgen %d", m);
341 pktgen_stop_cb(void *arg)
343 struct pktgen *pktg = arg;
345 pktg->pktg_flags |= PKTG_F_STOP;
349 pktgen_udp_thread1(void *arg)
351 struct pktgen *pktg = arg;
352 struct ifnet *ifp = pktg->pktg_ifp;
355 struct ether_header *eh;
359 int sw_csum, csum_flags;
361 uint64_t err_cnt, cnt;
362 in_addr_t saddr, daddr;
363 u_short sport, dport;
365 rel_mplock(); /* Don't need MP lock */
367 callout_reset(&pktg->pktg_stop, pktg->pktg_duration * hz,
368 pktgen_stop_cb, pktg);
373 ip_len = pktg->pktg_datalen + sizeof(*ui);
374 len = ip_len + ETHER_HDR_LEN;
376 psum = htons((u_short)pktg->pktg_datalen + sizeof(struct udphdr)
378 ulen = htons(pktg->pktg_datalen + sizeof(struct udphdr));
380 sw_csum = (CSUM_UDP | CSUM_IP) & ~ifp->if_hwassist;
381 csum_flags = (CSUM_UDP | CSUM_IP) & ifp->if_hwassist;
383 saddr = pktg->pktg_saddr;
384 daddr = pktg->pktg_daddr;
385 sport = pktg->pktg_sport;
386 dport = pktg->pktg_dport;
388 microtime(&pktg->pktg_start);
389 while ((pktg->pktg_flags & PKTG_F_STOP) == 0) {
390 m = m_getl(len, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
391 m->m_len = m->m_pkthdr.len = len;
393 m_adj(m, ETHER_HDR_LEN);
395 ui = mtod(m, struct udpiphdr *);
396 ui->ui_pr = IPPROTO_UDP;
397 ui->ui_src.s_addr = htonl(saddr);
398 ui->ui_dst.s_addr = htonl(daddr);
399 ui->ui_sport = htons(sport);
400 ui->ui_dport = htons(dport);
402 ui->ui_sum = in_pseudo(ui->ui_src.s_addr,
403 ui->ui_dst.s_addr, psum);
404 m->m_pkthdr.csum_flags = (CSUM_IP | CSUM_UDP);
405 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
407 ip = (struct ip *)ui;
409 ip->ip_ttl = 64; /* XXX */
410 ip->ip_tos = 0; /* XXX */
411 ip->ip_vhl = IP_VHL_BORING;
413 ip->ip_id = ip_newid();
415 if (sw_csum & CSUM_DELAY_DATA)
417 m->m_pkthdr.csum_flags = csum_flags;
419 ip->ip_len = htons(ip->ip_len);
421 if (sw_csum & CSUM_DELAY_IP)
422 ip->ip_sum = in_cksum_hdr(ip);
424 M_PREPEND(m, ETHER_HDR_LEN, MB_WAIT);
425 eh = mtod(m, struct ether_header *);
426 bcopy(pktg->pktg_dst_lladdr, eh->ether_dhost, ETHER_ADDR_LEN);
427 bcopy(IF_LLADDR(ifp), eh->ether_shost, ETHER_ADDR_LEN);
428 eh->ether_type = htons(ETHERTYPE_IP);
430 ifnet_serialize_tx(ifp);
431 error = ifq_handoff(ifp, m, NULL);
432 ifnet_deserialize_tx(ifp);
441 if (loop == pktg->pktg_yield) {
447 saddr = pktg->pktg_saddr + (r % pktg->pktg_nsaddr);
448 daddr = pktg->pktg_daddr + (r % pktg->pktg_ndaddr);
449 sport = pktg->pktg_sport + (r % pktg->pktg_nsport);
450 dport = pktg->pktg_dport + (r % pktg->pktg_ndport);
453 microtime(&pktg->pktg_end);
455 pktgen_thread_exit(pktg, cnt, err_cnt);
459 pktgen_udp_thread(void *arg)
461 struct pktgen *pktg = arg;
462 struct ifnet *ifp = pktg->pktg_ifp;
465 struct ether_header *eh;
469 int sw_csum, csum_flags;
471 uint64_t err_cnt, cnt;
472 in_addr_t saddr, daddr;
473 u_short sport, dport;
475 rel_mplock(); /* Don't need MP lock */
477 callout_reset(&pktg->pktg_stop, pktg->pktg_duration * hz,
478 pktgen_stop_cb, pktg);
483 ip_len = pktg->pktg_datalen + sizeof(*ui);
484 len = ip_len + ETHER_HDR_LEN;
486 saddr = htonl(pktg->pktg_saddr);
487 daddr = htonl(pktg->pktg_daddr);
488 sport = htons(pktg->pktg_sport);
489 dport = htons(pktg->pktg_dport);
491 sum = in_pseudo(saddr, daddr,
492 htons((u_short)pktg->pktg_datalen + sizeof(struct udphdr)
494 ulen = htons(pktg->pktg_datalen + sizeof(struct udphdr));
496 sw_csum = (CSUM_UDP | CSUM_IP) & ~ifp->if_hwassist;
497 csum_flags = (CSUM_UDP | CSUM_IP) & ifp->if_hwassist;
499 microtime(&pktg->pktg_start);
500 while ((pktg->pktg_flags & PKTG_F_STOP) == 0) {
501 m = m_getl(len, MB_WAIT, MT_DATA, M_PKTHDR, NULL);
502 m->m_len = m->m_pkthdr.len = len;
504 m_adj(m, ETHER_HDR_LEN);
506 ui = mtod(m, struct udpiphdr *);
507 ui->ui_pr = IPPROTO_UDP;
508 ui->ui_src.s_addr = saddr;
509 ui->ui_dst.s_addr = daddr;
510 ui->ui_sport = sport;
511 ui->ui_dport = dport;
514 m->m_pkthdr.csum_flags = (CSUM_IP | CSUM_UDP);
515 m->m_pkthdr.csum_data = offsetof(struct udphdr, uh_sum);
517 ip = (struct ip *)ui;
519 ip->ip_ttl = 64; /* XXX */
520 ip->ip_tos = 0; /* XXX */
521 ip->ip_vhl = IP_VHL_BORING;
523 ip->ip_id = ip_newid();
525 if (sw_csum & CSUM_DELAY_DATA)
527 m->m_pkthdr.csum_flags = csum_flags;
529 ip->ip_len = htons(ip->ip_len);
531 if (sw_csum & CSUM_DELAY_IP)
532 ip->ip_sum = in_cksum_hdr(ip);
534 M_PREPEND(m, ETHER_HDR_LEN, MB_WAIT);
535 eh = mtod(m, struct ether_header *);
536 bcopy(pktg->pktg_dst_lladdr, eh->ether_dhost, ETHER_ADDR_LEN);
537 bcopy(IF_LLADDR(ifp), eh->ether_shost, ETHER_ADDR_LEN);
538 eh->ether_type = htons(ETHERTYPE_IP);
540 ifnet_serialize_tx(ifp);
541 error = ifq_handoff(ifp, m, NULL);
542 ifnet_deserialize_tx(ifp);
551 if (loop == pktg->pktg_yield) {
557 microtime(&pktg->pktg_end);
559 pktgen_thread_exit(pktg, cnt, err_cnt);
563 pktgen_thread_exit(struct pktgen *pktg, uint64_t tx_cnt, uint64_t err_cnt)
567 pktg->pktg_tx_cnt = tx_cnt;
568 pktg->pktg_err_cnt = err_cnt;
570 end = pktg->pktg_end;
571 timevalsub(&end, &pktg->pktg_start);
572 kprintf("cnt %llu, err %llu, time %ld.%06ld\n",
573 pktg->pktg_tx_cnt, pktg->pktg_err_cnt, end.tv_sec, end.tv_usec);
575 pktg->pktg_flags &= ~(PKTG_F_STOP | PKTG_F_CONFIG | PKTG_F_RUNNING);
577 KKASSERT(pktg->pktg_refcnt > 0);
578 if (--pktg->pktg_refcnt == 0)
579 kfree(pktg, M_PKTGEN); /* XXX */
581 KKASSERT(pktgen_refcnt > 0);