开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pktgen.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：41k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pktgen.c：源码内容
  1. /* -*-linux-c-*-
  2.  * $Id: pktgen.c,v 1.8 2002/07/15 19:30:17 robert Exp $
  3.  * pktgen.c: Packet Generator for performance evaluation.
  4.  *
  5.  * Copyright 2001, 2002 by Robert Olsson <robert.olsson@its.uu.se>
  6.  *                                 Uppsala University, Sweden
  7.  *
  8.  * A tool for loading the network with preconfigurated packets.
  9.  * The tool is implemented as a linux module.  Parameters are output 
  10.  * device, IPG (interpacket gap), number of packets, and whether
  11.  * to use multiple SKBs or just the same one.
  12.  * pktgen uses the installed interface's output routine.
  13.  *
  14.  * Additional hacking by:
  15.  *
  16.  * Jens.Laas@data.slu.se
  17.  * Improved by ANK. 010120.
  18.  * Improved by ANK even more. 010212.
  19.  * MAC address typo fixed. 010417 --ro
  20.  * Integrated.  020301 --DaveM
  21.  * Added multiskb option 020301 --DaveM
  22.  * Scaling of results. 020417--sigurdur@linpro.no
  23.  * Significant re-work of the module:
  24.  *   *  Updated to support generation over multiple interfaces at once
  25.  *       by creating 32 /proc/net/pg* files.  Each file can be manipulated
  26.  *       individually.
  27.  *   *  Converted many counters to __u64 to allow longer runs.
  28.  *   *  Allow configuration of ranges, like min/max IP address, MACs,
  29.  *       and UDP-ports, for both source and destination, and can
  30.  *       set to use a random distribution or sequentially walk the range.
  31.  *   *  Can now change some values after starting.
  32.  *   *  Place 12-byte packet in UDP payload with magic number,
  33.  *       sequence number, and timestamp.  Will write receiver next.
  34.  *   *  The new changes seem to have a performance impact of around 1%,
  35.  *       as far as I can tell.
  36.  *   --Ben Greear <greearb@candelatech.com>
  37.  *
  38.  * Renamed multiskb to clone_skb and cleaned up sending core for two distinct 
  39.  * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0 
  40.  * as a "fastpath" with a configurable number of clones after alloc's.
  41.  *
  42.  * clone_skb=0 means all packets are allocated this also means ranges time 
  43.  * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100 
  44.  * clones.
  45.  *
  46.  * Also moved to /proc/net/pktgen/ 
  47.  * --ro 
  48.  *
  49.  * See Documentation/networking/pktgen.txt for how to use this.
  50.  */
  52. #include <linux/module.h>
  53. #include <linux/kernel.h>
  54. #include <linux/sched.h>
  55. #include <linux/types.h>
  56. #include <linux/string.h>
  57. #include <linux/ptrace.h>
  58. #include <linux/errno.h>
  59. #include <linux/ioport.h>
  60. #include <linux/slab.h>
  61. #include <linux/interrupt.h>
  62. #include <linux/pci.h>
  63. #include <linux/delay.h>
  64. #include <linux/init.h>
  65. #include <linux/inet.h>
  66. #include <asm/byteorder.h>
  67. #include <asm/bitops.h>
  68. #include <asm/io.h>
  69. #include <asm/dma.h>
  70. #include <asm/uaccess.h>
  72. #include <linux/in.h>
  73. #include <linux/ip.h>
  74. #include <linux/udp.h>
  75. #include <linux/skbuff.h>
  76. #include <linux/netdevice.h>
  77. #include <linux/inetdevice.h>
  78. #include <linux/rtnetlink.h>
  79. #include <linux/proc_fs.h>
  80. #include <linux/if_arp.h>
  81. #include <net/checksum.h>
  82. #include <asm/timex.h>
  84. #define cycles() ((u32)get_cycles())
  87. #define VERSION "pktgen version 1.2"
  88. static char version[] __initdata = 
  89.   "pktgen.c: v1.2: Packet Generator for packet performance testing.n";
  91. /* Used to help with determining the pkts on receive */
  93. #define PKTGEN_MAGIC 0xbe9be955
  96. /* Keep information per interface */
  97. struct pktgen_info {
  98.         /* Parameters */
  100.         /* If min != max, then we will either do a linear iteration, or
  101.          * we will do a random selection from within the range.
  102.          */
  103.         __u32 flags;     
  105. #define F_IPSRC_RND   (1<<0)  /* IP-Src Random  */
  106. #define F_IPDST_RND   (1<<1)  /* IP-Dst Random  */
  107. #define F_UDPSRC_RND  (1<<2)  /* UDP-Src Random */
  108. #define F_UDPDST_RND  (1<<3)  /* UDP-Dst Random */
  109. #define F_MACSRC_RND  (1<<4)  /* MAC-Src Random */
  110. #define F_MACDST_RND  (1<<5)  /* MAC-Dst Random */
  111. #define F_SET_SRCMAC  (1<<6)  /* Specify-Src-Mac 
  112.  (default is to use Interface's MAC Addr) */
  113. #define F_SET_SRCIP   (1<<7)  /*  Specify-Src-IP
  114.   (default is to use Interface's IP Addr) */ 
  116.         
  117.         int pkt_size;    /* = ETH_ZLEN; */
  118.         int nfrags;
  119.         __u32 ipg;       /* Default Interpacket gap in nsec */
  120.         __u64 count;     /* Default No packets to send */
  121.         __u64 sofar;     /* How many pkts we've sent so far */
  122.         __u64 errors;    /* Errors when trying to transmit, pkts will be re-sent */
  123.         struct timeval started_at;
  124.         struct timeval stopped_at;
  125.         __u64 idle_acc;
  126.         __u32 seq_num;
  127.         
  128.         int clone_skb;   /* Use multiple SKBs during packet gen.  If this number
  129.                           * is greater than 1, then that many coppies of the same
  130.                           * packet will be sent before a new packet is allocated.
  131.                           * For instance, if you want to send 1024 identical packets
  132.                           * before creating a new packet, set clone_skb to 1024.
  133.                           */
  134.         int busy;
  135.         int do_run_run;   /* if this changes to false, the test will stop */
  136.         
  137.         char outdev[32];
  138.         char dst_min[32];
  139.         char dst_max[32];
  140.         char src_min[32];
  141.         char src_max[32];
  143.         /* If we're doing ranges, random or incremental, then this
  144.          * defines the min/max for those ranges.
  145.          */
  146.         __u32 saddr_min; /* inclusive, source IP address */
  147.         __u32 saddr_max; /* exclusive, source IP address */
  148.         __u32 daddr_min; /* inclusive, dest IP address */
  149.         __u32 daddr_max; /* exclusive, dest IP address */
  151.         __u16 udp_src_min; /* inclusive, source UDP port */
  152.         __u16 udp_src_max; /* exclusive, source UDP port */
  153.         __u16 udp_dst_min; /* inclusive, dest UDP port */
  154.         __u16 udp_dst_max; /* exclusive, dest UDP port */
  156.         __u32 src_mac_count; /* How many MACs to iterate through */
  157.         __u32 dst_mac_count; /* How many MACs to iterate through */
  158.         
  159.         unsigned char dst_mac[6];
  160.         unsigned char src_mac[6];
  161.         
  162.         __u32 cur_dst_mac_offset;
  163.         __u32 cur_src_mac_offset;
  164.         __u32 cur_saddr;
  165.         __u32 cur_daddr;
  166.         __u16 cur_udp_dst;
  167.         __u16 cur_udp_src;
  168.         
  169.         __u8 hh[14];
  170.         /* = { 
  171.            0x00, 0x80, 0xC8, 0x79, 0xB3, 0xCB, 
  172.            
  173.            We fill in SRC address later
  174.            0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  175.            0x08, 0x00
  176.            };
  177.         */
  178.         __u16 pad; /* pad out the hh struct to an even 16 bytes */
  179.         char result[512];
  181.         /* proc file names */
  182.         char fname[80];
  183.         char busy_fname[80];
  184.         
  185.         struct proc_dir_entry *proc_ent;
  186.         struct proc_dir_entry *busy_proc_ent;
  187. };
  189. struct pktgen_hdr {
  190.         __u32 pgh_magic;
  191.         __u32 seq_num;
  192.         struct timeval timestamp;
  193. };
  195. static int cpu_speed;
  196. static int debug;
  198. /* Module parameters, defaults. */
  199. static int count_d = 100000;
  200. static int ipg_d = 0;
  201. static int clone_skb_d = 0;
  204. #define MAX_PKTGEN 8
  205. static struct pktgen_info pginfos[MAX_PKTGEN];
  208. /** Convert to miliseconds */
  209. inline __u64 tv_to_ms(const struct timeval* tv) {
  210.         __u64 ms = tv->tv_usec / 1000;
  211.         ms += (__u64)tv->tv_sec * (__u64)1000;
  212.         return ms;
  213. }
  215. inline __u64 getCurMs(void) {
  216.         struct timeval tv;
  217.         do_gettimeofday(&tv);
  218.         return tv_to_ms(&tv);
  219. }
  221. #define PG_PROC_DIR "pktgen"
  222. static struct proc_dir_entry *proc_dir = 0;
  224. static struct net_device *setup_inject(struct pktgen_info* info)
  225. {
  226. struct net_device *odev;
  228. rtnl_lock();
  229. odev = __dev_get_by_name(info->outdev);
  230. if (!odev) {
  231. sprintf(info->result, "No such netdevice: "%s"", info->outdev);
  232. goto out_unlock;
  233. }
  235. if (odev->type != ARPHRD_ETHER) {
  236. sprintf(info->result, "Not ethernet device: "%s"", info->outdev);
  237. goto out_unlock;
  238. }
  240. if (!netif_running(odev)) {
  241. sprintf(info->result, "Device is down: "%s"", info->outdev);
  242. goto out_unlock;
  243. }
  245.         /* Default to the interface's mac if not explicitly set. */
  246.         if (!(info->flags & F_SET_SRCMAC)) {
  247.                 memcpy(&(info->hh[6]), odev->dev_addr, 6);
  248.         }
  249.         else {
  250.                 memcpy(&(info->hh[6]), info->src_mac, 6);
  251.         }
  253.         /* Set up Dest MAC */
  254.         memcpy(&(info->hh[0]), info->dst_mac, 6);
  255.         
  256. info->saddr_min = 0;
  257. info->saddr_max = 0;
  258.         if (strlen(info->src_min) == 0) {
  259.                 if (odev->ip_ptr) {
  260.                         struct in_device *in_dev = odev->ip_ptr;
  262.                         if (in_dev->ifa_list) {
  263.                                 info->saddr_min = in_dev->ifa_list->ifa_address;
  264.                                 info->saddr_max = info->saddr_min;
  265.                         }
  266.                 }
  267. }
  268.         else {
  269.                 info->saddr_min = in_aton(info->src_min);
  270.                 info->saddr_max = in_aton(info->src_max);
  271.         }
  273.         info->daddr_min = in_aton(info->dst_min);
  274.         info->daddr_max = in_aton(info->dst_max);
  276.         /* Initialize current values. */
  277.         info->cur_dst_mac_offset = 0;
  278.         info->cur_src_mac_offset = 0;
  279.         info->cur_saddr = info->saddr_min;
  280.         info->cur_daddr = info->daddr_min;
  281.         info->cur_udp_dst = info->udp_dst_min;
  282.         info->cur_udp_src = info->udp_src_min;
  283.         
  284. atomic_inc(&odev->refcnt);
  285. rtnl_unlock();
  287. return odev;
  289. out_unlock:
  290. rtnl_unlock();
  291. return NULL;
  292. }
  294. static void nanospin(int ipg, struct pktgen_info* info)
  295. {
  296. u32 idle_start, idle;
  298. idle_start = cycles();
  300. for (;;) {
  301. barrier();
  302. idle = cycles() - idle_start;
  303. if (idle * 1000 >= ipg * cpu_speed)
  304. break;
  305. }
  306. info->idle_acc += idle;
  307. }
  309. static int calc_mhz(void)
  310. {
  311. struct timeval start, stop;
  312. u32 start_s, elapsed;
  314. do_gettimeofday(&start);
  315. start_s = cycles();
  316. do {
  317. barrier();
  318. elapsed = cycles() - start_s;
  319. if (elapsed == 0)
  320. return 0;
  321. } while (elapsed < 1000 * 50000);
  322. do_gettimeofday(&stop);
  323. return elapsed/(stop.tv_usec-start.tv_usec+1000000*(stop.tv_sec-start.tv_sec));
  324. }
  326. static void cycles_calibrate(void)
  327. {
  328. int i;
  330. for (i = 0; i < 3; i++) {
  331. int res = calc_mhz();
  332. if (res > cpu_speed)
  333. cpu_speed = res;
  334. }
  335. }
  338. /* Increment/randomize headers according to flags and current values
  339.  * for IP src/dest, UDP src/dst port, MAC-Addr src/dst
  340.  */
  341. static void mod_cur_headers(struct pktgen_info* info) {        
  342.         __u32 imn;
  343.         __u32 imx;
  344.         
  345. /*  Deal with source MAC */
  346.         if (info->src_mac_count > 1) {
  347.                 __u32 mc;
  348.                 __u32 tmp;
  349.                 if (info->flags & F_MACSRC_RND) {
  350.                         mc = net_random() % (info->src_mac_count);
  351.                 }
  352.                 else {
  353.                         mc = info->cur_src_mac_offset++;
  354.                         if (info->cur_src_mac_offset > info->src_mac_count) {
  355.                                 info->cur_src_mac_offset = 0;
  356.                         }
  357.                 }
  359.                 tmp = info->src_mac[5] + (mc & 0xFF);
  360.                 info->hh[11] = tmp;
  361.                 tmp = (info->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
  362.                 info->hh[10] = tmp;
  363.                 tmp = (info->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
  364.                 info->hh[9] = tmp;
  365.                 tmp = (info->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
  366.                 info->hh[8] = tmp;
  367.                 tmp = (info->src_mac[1] + (tmp >> 8));
  368.                 info->hh[7] = tmp;        
  369.         }
  371.         /*  Deal with Destination MAC */
  372.         if (info->dst_mac_count > 1) {
  373.                 __u32 mc;
  374.                 __u32 tmp;
  375.                 if (info->flags & F_MACDST_RND) {
  376.                         mc = net_random() % (info->dst_mac_count);
  377.                 }
  378.                 else {
  379.                         mc = info->cur_dst_mac_offset++;
  380.                         if (info->cur_dst_mac_offset > info->dst_mac_count) {
  381.                                 info->cur_dst_mac_offset = 0;
  382.                         }
  383.                 }
  385.                 tmp = info->dst_mac[5] + (mc & 0xFF);
  386.                 info->hh[5] = tmp;
  387.                 tmp = (info->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
  388.                 info->hh[4] = tmp;
  389.                 tmp = (info->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
  390.                 info->hh[3] = tmp;
  391.                 tmp = (info->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
  392.                 info->hh[2] = tmp;
  393.                 tmp = (info->dst_mac[1] + (tmp >> 8));
  394.                 info->hh[1] = tmp;        
  395.         }
  397.         if (info->udp_src_min < info->udp_src_max) {
  398.                 if (info->flags & F_UDPSRC_RND) {
  399.                         info->cur_udp_src = ((net_random() % (info->udp_src_max - info->udp_src_min))
  400.                                              + info->udp_src_min);
  401.                 }
  402.                 else {
  403.                      info->cur_udp_src++;
  404.                      if (info->cur_udp_src >= info->udp_src_max) {
  405.                              info->cur_udp_src = info->udp_src_min;
  406.                      }
  407.                 }
  408.         }
  410.         if (info->udp_dst_min < info->udp_dst_max) {
  411.                 if (info->flags & F_UDPDST_RND) {
  412.                         info->cur_udp_dst = ((net_random() % (info->udp_dst_max - info->udp_dst_min))
  413.                                              + info->udp_dst_min);
  414.                 }
  415.                 else {
  416.                      info->cur_udp_dst++;
  417.                      if (info->cur_udp_dst >= info->udp_dst_max) {
  418.                              info->cur_udp_dst = info->udp_dst_min;
  419.                      }
  420.                 }
  421.         }
  423.         if ((imn = ntohl(info->saddr_min)) < (imx = ntohl(info->saddr_max))) {
  424.                 __u32 t;
  425.                 if (info->flags & F_IPSRC_RND) {
  426.                         t = ((net_random() % (imx - imn)) + imn);
  427.                 }
  428.                 else {
  429.                      t = ntohl(info->cur_saddr);
  430.                      t++;
  431.                      if (t >= imx) {
  432.                              t = imn;
  433.                      }
  434.                 }
  435.                 info->cur_saddr = htonl(t);
  436.         }
  438.         if ((imn = ntohl(info->daddr_min)) < (imx = ntohl(info->daddr_max))) {
  439.                 __u32 t;
  440.                 if (info->flags & F_IPDST_RND) {
  441.                         t = ((net_random() % (imx - imn)) + imn);
  442.                 }
  443.                 else {
  444.                      t = ntohl(info->cur_daddr);
  445.                      t++;
  446.                      if (t >= imx) {
  447.                              t = imn;
  448.                      }
  449.                 }
  450.                 info->cur_daddr = htonl(t);
  451.         }
  452. }/* mod_cur_headers */
  455. static struct sk_buff *fill_packet(struct net_device *odev, struct pktgen_info* info)
  456. {
  457. struct sk_buff *skb = NULL;
  458. __u8 *eth;
  459. struct udphdr *udph;
  460. int datalen, iplen;
  461. struct iphdr *iph;
  462.         struct pktgen_hdr *pgh = NULL;
  463.         
  464. skb = alloc_skb(info->pkt_size + 64 + 16, GFP_ATOMIC);
  465. if (!skb) {
  466. sprintf(info->result, "No memory");
  467. return NULL;
  468. }
  470. skb_reserve(skb, 16);
  472. /*  Reserve for ethernet and IP header  */
  473. eth = (__u8 *) skb_push(skb, 14);
  474. iph = (struct iphdr *)skb_put(skb, sizeof(struct iphdr));
  475. udph = (struct udphdr *)skb_put(skb, sizeof(struct udphdr));
  477.         /* Update any of the values, used when we're incrementing various
  478.          * fields.
  479.          */
  480.         mod_cur_headers(info);
  482. memcpy(eth, info->hh, 14);
  483.         
  484. datalen = info->pkt_size - 14 - 20 - 8; /* Eth + IPh + UDPh */
  485. if (datalen < sizeof(struct pktgen_hdr)) {
  486. datalen = sizeof(struct pktgen_hdr);
  487.         }
  488.         
  489. udph->source = htons(info->cur_udp_src);
  490. udph->dest = htons(info->cur_udp_dst);
  491. udph->len = htons(datalen + 8); /* DATA + udphdr */
  492. udph->check = 0;  /* No checksum */
  494. iph->ihl = 5;
  495. iph->version = 4;
  496. iph->ttl = 3;
  497. iph->tos = 0;
  498. iph->protocol = IPPROTO_UDP; /* UDP */
  499. iph->saddr = info->cur_saddr;
  500. iph->daddr = info->cur_daddr;
  501. iph->frag_off = 0;
  502. iplen = 20 + 8 + datalen;
  503. iph->tot_len = htons(iplen);
  504. iph->check = 0;
  505. iph->check = ip_fast_csum((void *) iph, iph->ihl);
  506. skb->protocol = __constant_htons(ETH_P_IP);
  507. skb->mac.raw = ((u8 *)iph) - 14;
  508. skb->dev = odev;
  509. skb->pkt_type = PACKET_HOST;
  511. if (info->nfrags <= 0) {
  512.                 pgh = (struct pktgen_hdr *)skb_put(skb, datalen);
  513. } else {
  514. int frags = info->nfrags;
  515. int i;
  517.                 /* TODO: Verify this is OK...it sure is ugly. --Ben */
  518.                 pgh = (struct pktgen_hdr*)(((char*)(udph)) + 8);
  519.                 
  520. if (frags > MAX_SKB_FRAGS)
  521. frags = MAX_SKB_FRAGS;
  522. if (datalen > frags*PAGE_SIZE) {
  523. skb_put(skb, datalen-frags*PAGE_SIZE);
  524. datalen = frags*PAGE_SIZE;
  525. }
  527. i = 0;
  528. while (datalen > 0) {
  529. struct page *page = alloc_pages(GFP_KERNEL, 0);
  530. skb_shinfo(skb)->frags[i].page = page;
  531. skb_shinfo(skb)->frags[i].page_offset = 0;
  532. skb_shinfo(skb)->frags[i].size =
  533. (datalen < PAGE_SIZE ? datalen : PAGE_SIZE);
  534. datalen -= skb_shinfo(skb)->frags[i].size;
  535. skb->len += skb_shinfo(skb)->frags[i].size;
  536. skb->data_len += skb_shinfo(skb)->frags[i].size;
  537. i++;
  538. skb_shinfo(skb)->nr_frags = i;
  539. }
  541. while (i < frags) {
  542. int rem;
  544. if (i == 0)
  545. break;
  547. rem = skb_shinfo(skb)->frags[i - 1].size / 2;
  548. if (rem == 0)
  549. break;
  551. skb_shinfo(skb)->frags[i - 1].size -= rem;
  553. skb_shinfo(skb)->frags[i] = skb_shinfo(skb)->frags[i - 1];
  554. get_page(skb_shinfo(skb)->frags[i].page);
  555. skb_shinfo(skb)->frags[i].page = skb_shinfo(skb)->frags[i - 1].page;
  556. skb_shinfo(skb)->frags[i].page_offset += skb_shinfo(skb)->frags[i - 1].size;
  557. skb_shinfo(skb)->frags[i].size = rem;
  558. i++;
  559. skb_shinfo(skb)->nr_frags = i;
  560. }
  561. }
  563.         /* Stamp the time, and sequence number, convert them to network byte order */
  564.         if (pgh) {
  565.                 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
  566.                 do_gettimeofday(&(pgh->timestamp));
  567.                 pgh->timestamp.tv_usec = htonl(pgh->timestamp.tv_usec);
  568.                 pgh->timestamp.tv_sec = htonl(pgh->timestamp.tv_sec);
  569.                 pgh->seq_num = htonl(info->seq_num);
  570.         }
  571.         
  572. return skb;
  573. }
  576. static void inject(struct pktgen_info* info)
  577. {
  578. struct net_device *odev = NULL;
  579. struct sk_buff *skb = NULL;
  580. __u64 total = 0;
  581.         __u64 idle = 0;
  582. __u64 lcount = 0;
  583.         int nr_frags = 0;
  584. int last_ok = 1;           /* Was last skb sent? 
  585.                             * Or a failed transmit of some sort?  This will keep
  586.                                     * sequence numbers in order, for example.
  587.                                     */
  588.         __u64 fp = 0;
  589.         __u32 fp_tmp = 0;
  591. odev = setup_inject(info);
  592. if (!odev)
  593. return;
  595.         info->do_run_run = 1; /* Cranke yeself! */
  596. info->idle_acc = 0;
  597. info->sofar = 0;
  598. lcount = info->count;
  601.         /* Build our initial pkt and place it as a re-try pkt. */
  602. skb = fill_packet(odev, info);
  603. if (skb == NULL) goto out_reldev;
  605. do_gettimeofday(&(info->started_at));
  607. while(info->do_run_run) {
  609.                 /* Set a time-stamp, so build a new pkt each time */
  611.                 if (last_ok) {
  612.                         if (++fp_tmp >= info->clone_skb ) {
  613.                                 kfree_skb(skb);
  614.                                 skb = fill_packet(odev, info);
  615.                                 if (skb == NULL) {
  616.                                         break;
  617.                                 }
  618.                                 fp++;
  619.                                 fp_tmp = 0; /* reset counter */
  620.                         }
  621.                         atomic_inc(&skb->users);
  622.                 }
  624.                 nr_frags = skb_shinfo(skb)->nr_frags;
  625.                    
  626. spin_lock_bh(&odev->xmit_lock);
  627. if (!netif_queue_stopped(odev)) {
  629. if (odev->hard_start_xmit(skb, odev)) {
  630. if (net_ratelimit()) {
  631.                                    printk(KERN_INFO "Hard xmit errorn");
  632.                                 }
  633.                                 info->errors++;
  634. last_ok = 0;
  635. }
  636.                         else {
  637.            last_ok = 1;
  638.                            info->sofar++;
  639.                            info->seq_num++;
  640.                         }
  641. }
  642. else {
  643.                         /* Re-try it next time */
  644. last_ok = 0;
  645.                 }
  646.                 
  648. spin_unlock_bh(&odev->xmit_lock);
  650. if (info->ipg) {
  651.                         /* Try not to busy-spin if we have larger sleep times.
  652.                          * TODO:  Investigate better ways to do this.
  653.                          */
  654.                         if (info->ipg < 10000) { /* 10 usecs or less */
  655.                                 nanospin(info->ipg, info);
  656.                         }
  657.                         else if (info->ipg < 10000000) { /* 10ms or less */
  658.                                 udelay(info->ipg / 1000);
  659.                         }
  660.                         else {
  661.                                 mdelay(info->ipg / 1000000);
  662.                         }
  663.                 }
  664.                 
  665. if (signal_pending(current)) {
  666.                         break;
  667.                 }
  669.                 /* If lcount is zero, then run forever */
  670. if ((lcount != 0) && (--lcount == 0)) {
  671. if (atomic_read(&skb->users) != 1) {
  672. u32 idle_start, idle;
  674. idle_start = cycles();
  675. while (atomic_read(&skb->users) != 1) {
  676. if (signal_pending(current)) {
  677.                                                 break;
  678.                                         }
  679. schedule();
  680. }
  681. idle = cycles() - idle_start;
  682. info->idle_acc += idle;
  683. }
  684. break;
  685. }
  687. if (netif_queue_stopped(odev) || current->need_resched) {
  688. u32 idle_start, idle;
  690. idle_start = cycles();
  691. do {
  692. if (signal_pending(current)) {
  693.                                         info->do_run_run = 0;
  694.                                         break;
  695.                                 }
  696. if (!netif_running(odev)) {
  697.                                         info->do_run_run = 0;
  698. break;
  699.                                 }
  700. if (current->need_resched)
  701. schedule();
  702. else
  703. do_softirq();
  704. } while (netif_queue_stopped(odev));
  705. idle = cycles() - idle_start;
  706. info->idle_acc += idle;
  707. }
  708. }/* while we should be running */
  710. do_gettimeofday(&(info->stopped_at));
  712. total = (info->stopped_at.tv_sec - info->started_at.tv_sec) * 1000000 +
  713. info->stopped_at.tv_usec - info->started_at.tv_usec;
  715. idle = (__u32)(info->idle_acc)/(__u32)(cpu_speed);
  717.         {
  718. char *p = info->result;
  719.                 __u64 pps = (__u32)(info->sofar * 1000) / ((__u32)(total) / 1000);
  720.                 __u64 bps = pps * 8 * (info->pkt_size + 4); /* take 32bit ethernet CRC into account */
  721. p += sprintf(p, "OK: %llu(c%llu+d%llu) usec, %llu (%dbyte,%dfrags) %llupps %lluMb/sec (%llubps)  errors: %llu",
  722.      (unsigned long long) total,
  723.      (unsigned long long) (total - idle),
  724.      (unsigned long long) idle,
  725.      (unsigned long long) info->sofar,
  726.                              skb->len + 4, /* Add 4 to account for the ethernet checksum */
  727.                              nr_frags,
  728.      (unsigned long long) pps,
  729.      (unsigned long long) (bps / (u64) 1024 / (u64) 1024),
  730.      (unsigned long long) bps,
  731.      (unsigned long long) info->errors
  732.      );
  733. }
  734.         
  735. out_reldev:
  736.         if (odev) {
  737.                 dev_put(odev);
  738.                 odev = NULL;
  739.         }
  741.         /* TODO:  Is this worth printing out (other than for debug?) */
  742.         printk("fp = %llun", (unsigned long long) fp);
  743. return;
  745. }
  747. /* proc/net/pktgen/pg */
  749. static int proc_busy_read(char *buf , char **start, off_t offset,
  750.      int len, int *eof, void *data)
  751. {
  752. char *p;
  753.         int idx = (int)(long)(data);
  754.         struct pktgen_info* info = NULL;
  755.         
  756.         if ((idx < 0) || (idx >= MAX_PKTGEN)) {
  757.                 printk("ERROR: idx: %i is out of range in proc_writen", idx);
  758.                 return -EINVAL;
  759.         }
  760.         info = &(pginfos[idx]);
  761.   
  762. p = buf;
  763. p += sprintf(p, "%dn", info->busy);
  764. *eof = 1;
  765.   
  766. return p-buf;
  767. }
  769. static int proc_read(char *buf , char **start, off_t offset,
  770. int len, int *eof, void *data)
  771. {
  772. char *p;
  773. int i;
  774.         int idx = (int)(long)(data);
  775.         struct pktgen_info* info = NULL;
  776.         __u64 sa;
  777.         __u64 stopped;
  778.         __u64 now = getCurMs();
  779.         
  780.         if ((idx < 0) || (idx >= MAX_PKTGEN)) {
  781.                 printk("ERROR: idx: %i is out of range in proc_writen", idx);
  782.                 return -EINVAL;
  783.         }
  784.         info = &(pginfos[idx]);
  785.   
  786. p = buf;
  787.         p += sprintf(p, "%sn", VERSION); /* Help with parsing compatibility */
  788. p += sprintf(p, "Params: count %llu  pkt_size: %u  frags: %d  ipg: %u  clone_skb: %d odev "%s"n",
  789.      (unsigned long long) info->count,
  790.      info->pkt_size, info->nfrags, info->ipg,
  791.                      info->clone_skb, info->outdev);
  792.         p += sprintf(p, "     dst_min: %s  dst_max: %s  src_min: %s  src_max: %sn",
  793.                      info->dst_min, info->dst_max, info->src_min, info->src_max);
  794.         p += sprintf(p, "     src_mac: ");
  795. for (i = 0; i < 6; i++) {
  796. p += sprintf(p, "%02X%s", info->src_mac[i], i == 5 ? "  " : ":");
  797.         }
  798.         p += sprintf(p, "dst_mac: ");
  799. for (i = 0; i < 6; i++) {
  800. p += sprintf(p, "%02X%s", info->dst_mac[i], i == 5 ? "n" : ":");
  801.         }
  802.         p += sprintf(p, "     udp_src_min: %d  udp_src_max: %d  udp_dst_min: %d  udp_dst_max: %dn",
  803.                      info->udp_src_min, info->udp_src_max, info->udp_dst_min,
  804.                      info->udp_dst_max);
  805.         p += sprintf(p, "     src_mac_count: %d  dst_mac_count: %dn     Flags: ",
  806.                      info->src_mac_count, info->dst_mac_count);
  807.         if (info->flags &  F_IPSRC_RND) {
  808.                 p += sprintf(p, "IPSRC_RND  ");
  809.         }
  810.         if (info->flags & F_IPDST_RND) {
  811.                 p += sprintf(p, "IPDST_RND  ");
  812.         }
  813.         if (info->flags & F_UDPSRC_RND) {
  814.                 p += sprintf(p, "UDPSRC_RND  ");
  815.         }
  816.         if (info->flags & F_UDPDST_RND) {
  817.                 p += sprintf(p, "UDPDST_RND  ");
  818.         }
  819.         if (info->flags & F_MACSRC_RND) {
  820.                 p += sprintf(p, "MACSRC_RND  ");
  821.         }
  822.         if (info->flags & F_MACDST_RND) {
  823.                 p += sprintf(p, "MACDST_RND  ");
  824.         }
  825.         p += sprintf(p, "n");
  826.         
  827.         sa = tv_to_ms(&(info->started_at));
  828.         stopped = tv_to_ms(&(info->stopped_at));
  829.         if (info->do_run_run) {
  830.                 stopped = now; /* not really stopped, more like last-running-at */
  831.         }
  832.         p += sprintf(p, "Current:n     pkts-sofar: %llu  errors: %llun     started: %llums  stopped: %llums  now: %llums  idle: %llunsn",
  833.                      (unsigned long long) info->sofar,
  834.      (unsigned long long) info->errors,
  835.      (unsigned long long) sa,
  836.      (unsigned long long) stopped,
  837.      (unsigned long long) now,
  838.      (unsigned long long) info->idle_acc);
  839.         p += sprintf(p, "     seq_num: %d  cur_dst_mac_offset: %d  cur_src_mac_offset: %dn",
  840.                      info->seq_num, info->cur_dst_mac_offset, info->cur_src_mac_offset);
  841.         p += sprintf(p, "     cur_saddr: 0x%x  cur_daddr: 0x%x  cur_udp_dst: %d  cur_udp_src: %dn",
  842.                      info->cur_saddr, info->cur_daddr, info->cur_udp_dst, info->cur_udp_src);
  843.         
  844. if (info->result[0])
  845. p += sprintf(p, "Result: %sn", info->result);
  846. else
  847. p += sprintf(p, "Result: Idlen");
  848. *eof = 1;
  850. return p - buf;
  851. }
  853. static int count_trail_chars(const char *user_buffer, unsigned int maxlen)
  854. {
  855. int i;
  857. for (i = 0; i < maxlen; i++) {
  858. char c;
  860. if (get_user(c, &user_buffer[i]))
  861. return -EFAULT;
  862. switch (c) {
  863. case '"':
  864. case 'n':
  865. case 'r':
  866. case 't':
  867. case ' ':
  868. case '=':
  869. break;
  870. default:
  871. goto done;
  872. };
  873. }
  874. done:
  875. return i;
  876. }
  878. static unsigned long num_arg(const char *user_buffer, unsigned long maxlen,
  879.      unsigned long *num)
  880. {
  881. int i = 0;
  883. *num = 0;
  884.   
  885. for(; i < maxlen; i++) {
  886. char c;
  888. if (get_user(c, &user_buffer[i]))
  889. return -EFAULT;
  890. if ((c >= '0') && (c <= '9')) {
  891. *num *= 10;
  892. *num += c -'0';
  893. } else
  894. break;
  895. }
  896. return i;
  897. }
  899. static int strn_len(const char *user_buffer, unsigned int maxlen)
  900. {
  901. int i = 0;
  903. for(; i < maxlen; i++) {
  904. char c;
  906. if (get_user(c, &user_buffer[i]))
  907. return -EFAULT;
  908. switch (c) {
  909. case '"':
  910. case 'n':
  911. case 'r':
  912. case 't':
  913. case ' ':
  914. goto done_str;
  915. default:
  916. break;
  917. };
  918. }
  919. done_str:
  920. return i;
  921. }
  923. static int proc_write(struct file *file, const char *user_buffer,
  924.  unsigned long count, void *data)
  925. {
  926. int i = 0, max, len;
  927. char name[16], valstr[32];
  928. unsigned long value = 0;
  929.         int idx = (int)(long)(data);
  930.         struct pktgen_info* info = NULL;
  931.         char* result = NULL;
  932. int tmp;
  933.         
  934.         if ((idx < 0) || (idx >= MAX_PKTGEN)) {
  935.                 printk("ERROR: idx: %i is out of range in proc_writen", idx);
  936.                 return -EINVAL;
  937.         }
  938.         info = &(pginfos[idx]);
  939.         result = &(info->result[0]);
  940.         
  941. if (count < 1) {
  942. sprintf(result, "Wrong command format");
  943. return -EINVAL;
  944. }
  945.   
  946. max = count - i;
  947. tmp = count_trail_chars(&user_buffer[i], max);
  948. if (tmp < 0)
  949. return tmp;
  950. i += tmp;
  951.   
  952. /* Read variable name */
  954. len = strn_len(&user_buffer[i], sizeof(name) - 1);
  955. if (len < 0)
  956. return len;
  957. memset(name, 0, sizeof(name));
  958. copy_from_user(name, &user_buffer[i], len);
  959. i += len;
  960.   
  961. max = count -i;
  962. len = count_trail_chars(&user_buffer[i], max);
  963. if (len < 0)
  964. return len;
  965. i += len;
  967. if (debug)
  968. printk("pg: %s,%lun", name, count);
  970. if (!strcmp(name, "stop")) {
  971. if (info->do_run_run) {
  972. strcpy(result, "Stopping");
  973.                 }
  974.                 else {
  975.                         strcpy(result, "Already stopped...n");
  976.                 }
  977.                 info->do_run_run = 0;
  978. return count;
  979. }
  981. if (!strcmp(name, "pkt_size")) {
  982. len = num_arg(&user_buffer[i], 10, &value);
  983. if (len < 0)
  984. return len;
  985. i += len;
  986. if (value < 14+20+8)
  987. value = 14+20+8;
  988. info->pkt_size = value;
  989. sprintf(result, "OK: pkt_size=%u", info->pkt_size);
  990. return count;
  991. }
  992. if (!strcmp(name, "frags")) {
  993. len = num_arg(&user_buffer[i], 10, &value);
  994. if (len < 0)
  995. return len;
  996. i += len;
  997. info->nfrags = value;
  998. sprintf(result, "OK: frags=%u", info->nfrags);
  999. return count;
  1000. }
  1001. if (!strcmp(name, "ipg")) {
  1002. len = num_arg(&user_buffer[i], 10, &value);
  1003. if (len < 0)
  1004. return len;
  1005. i += len;
  1006. info->ipg = value;
  1007. sprintf(result, "OK: ipg=%u", info->ipg);
  1008. return count;
  1009. }
  1010.   if (!strcmp(name, "udp_src_min")) {
  1011. len = num_arg(&user_buffer[i], 10, &value);
  1012. if (len < 0)
  1013. return len;
  1014. i += len;
  1015.   info->udp_src_min = value;
  1016. sprintf(result, "OK: udp_src_min=%u", info->udp_src_min);
  1017. return count;
  1018. }
  1019.   if (!strcmp(name, "udp_dst_min")) {
  1020. len = num_arg(&user_buffer[i], 10, &value);
  1021. if (len < 0)
  1022. return len;
  1023. i += len;
  1024.   info->udp_dst_min = value;
  1025. sprintf(result, "OK: udp_dst_min=%u", info->udp_dst_min);
  1026. return count;
  1027. }
  1028.   if (!strcmp(name, "udp_src_max")) {
  1029. len = num_arg(&user_buffer[i], 10, &value);
  1030. if (len < 0)
  1031. return len;
  1032. i += len;
  1033.   info->udp_src_max = value;
  1034. sprintf(result, "OK: udp_src_max=%u", info->udp_src_max);
  1035. return count;
  1036. }
  1037.   if (!strcmp(name, "udp_dst_max")) {
  1038. len = num_arg(&user_buffer[i], 10, &value);
  1039. if (len < 0)
  1040. return len;
  1041. i += len;
  1042.   info->udp_dst_max = value;
  1043. sprintf(result, "OK: udp_dst_max=%u", info->udp_dst_max);
  1044. return count;
  1045. }
  1046. if (!strcmp(name, "clone_skb")) {
  1047. len = num_arg(&user_buffer[i], 10, &value);
  1048. if (len < 0)
  1049. return len;
  1050. i += len;
  1051.                 info->clone_skb = value;
  1053. sprintf(result, "OK: clone_skb=%d", info->clone_skb);
  1054. return count;
  1055. }
  1056. if (!strcmp(name, "count")) {
  1057. len = num_arg(&user_buffer[i], 10, &value);
  1058. if (len < 0)
  1059. return len;
  1060. i += len;
  1061. info->count = value;
  1062. sprintf(result, "OK: count=%llu", (unsigned long long) info->count);
  1063. return count;
  1064. }
  1065. if (!strcmp(name, "src_mac_count")) {
  1066. len = num_arg(&user_buffer[i], 10, &value);
  1067. if (len < 0)
  1068. return len;
  1069. i += len;
  1070. info->src_mac_count = value;
  1071. sprintf(result, "OK: src_mac_count=%d", info->src_mac_count);
  1072. return count;
  1073. }
  1074. if (!strcmp(name, "dst_mac_count")) {
  1075. len = num_arg(&user_buffer[i], 10, &value);
  1076. if (len < 0)
  1077. return len;
  1078. i += len;
  1079. info->dst_mac_count = value;
  1080. sprintf(result, "OK: dst_mac_count=%d", info->dst_mac_count);
  1081. return count;
  1082. }
  1083. if (!strcmp(name, "odev")) {
  1084. len = strn_len(&user_buffer[i], sizeof(info->outdev) - 1);
  1085. if (len < 0)
  1086. return len;
  1087. memset(info->outdev, 0, sizeof(info->outdev));
  1088. copy_from_user(info->outdev, &user_buffer[i], len);
  1089. i += len;
  1090. sprintf(result, "OK: odev=%s", info->outdev);
  1091. return count;
  1092. }
  1093. if (!strcmp(name, "flag")) {
  1094.                 char f[32];
  1095.                 memset(f, 0, 32);
  1096. len = strn_len(&user_buffer[i], sizeof(f) - 1);
  1097. if (len < 0)
  1098. return len;
  1099. copy_from_user(f, &user_buffer[i], len);
  1100. i += len;
  1101.                 if (strcmp(f, "IPSRC_RND") == 0) {
  1102.                         info->flags |= F_IPSRC_RND;
  1103.                 }
  1104.                 else if (strcmp(f, "!IPSRC_RND") == 0) {
  1105.                         info->flags &= ~F_IPSRC_RND;
  1106.                 }
  1107.                 else if (strcmp(f, "IPDST_RND") == 0) {
  1108.                         info->flags |= F_IPDST_RND;
  1109.                 }
  1110.                 else if (strcmp(f, "!IPDST_RND") == 0) {
  1111.                         info->flags &= ~F_IPDST_RND;
  1112.                 }
  1113.                 else if (strcmp(f, "UDPSRC_RND") == 0) {
  1114.                         info->flags |= F_UDPSRC_RND;
  1115.                 }
  1116.                 else if (strcmp(f, "!UDPSRC_RND") == 0) {
  1117.                         info->flags &= ~F_UDPSRC_RND;
  1118.                 }
  1119.                 else if (strcmp(f, "UDPDST_RND") == 0) {
  1120.                         info->flags |= F_UDPDST_RND;
  1121.                 }
  1122.                 else if (strcmp(f, "!UDPDST_RND") == 0) {
  1123.                         info->flags &= ~F_UDPDST_RND;
  1124.                 }
  1125.                 else if (strcmp(f, "MACSRC_RND") == 0) {
  1126.                         info->flags |= F_MACSRC_RND;
  1127.                 }
  1128.                 else if (strcmp(f, "!MACSRC_RND") == 0) {
  1129.                         info->flags &= ~F_MACSRC_RND;
  1130.                 }
  1131.                 else if (strcmp(f, "MACDST_RND") == 0) {
  1132.                         info->flags |= F_MACDST_RND;
  1133.                 }
  1134.                 else if (strcmp(f, "!MACDST_RND") == 0) {
  1135.                         info->flags &= ~F_MACDST_RND;
  1136.                 }
  1137.                 else {
  1138.                         sprintf(result, "Flag -:%s:- unknownnAvailable flags, (prepend ! to un-set flag):n%s",
  1139.                                 f,
  1140.                                 "IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, MACSRC_RND, MACDST_RNDn");
  1141.                         return count;
  1142.                 }
  1143. sprintf(result, "OK: flags=0x%x", info->flags);
  1144. return count;
  1145. }
  1146. if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) {
  1147. len = strn_len(&user_buffer[i], sizeof(info->dst_min) - 1);
  1148. if (len < 0)
  1149. return len;
  1150. memset(info->dst_min, 0, sizeof(info->dst_min));
  1151. copy_from_user(info->dst_min, &user_buffer[i], len);
  1152. if(debug)
  1153. printk("pg: dst_min set to: %sn", info->dst_min);
  1154. i += len;
  1155. sprintf(result, "OK: dst_min=%s", info->dst_min);
  1156. return count;
  1157. }
  1158. if (!strcmp(name, "dst_max")) {
  1159. len = strn_len(&user_buffer[i], sizeof(info->dst_max) - 1);
  1160. if (len < 0)
  1161. return len;
  1162. memset(info->dst_max, 0, sizeof(info->dst_max));
  1163. copy_from_user(info->dst_max, &user_buffer[i], len);
  1164. if(debug)
  1165. printk("pg: dst_max set to: %sn", info->dst_max);
  1166. i += len;
  1167. sprintf(result, "OK: dst_max=%s", info->dst_max);
  1168. return count;
  1169. }
  1170. if (!strcmp(name, "src_min")) {
  1171. len = strn_len(&user_buffer[i], sizeof(info->src_min) - 1);
  1172. if (len < 0)
  1173. return len;
  1174. memset(info->src_min, 0, sizeof(info->src_min));
  1175. copy_from_user(info->src_min, &user_buffer[i], len);
  1176. if(debug)
  1177. printk("pg: src_min set to: %sn", info->src_min);
  1178. i += len;
  1179. sprintf(result, "OK: src_min=%s", info->src_min);
  1180. return count;
  1181. }
  1182. if (!strcmp(name, "src_max")) {
  1183. len = strn_len(&user_buffer[i], sizeof(info->src_max) - 1);
  1184. if (len < 0)
  1185. return len;
  1186. memset(info->src_max, 0, sizeof(info->src_max));
  1187. copy_from_user(info->src_max, &user_buffer[i], len);
  1188. if(debug)
  1189. printk("pg: src_max set to: %sn", info->src_max);
  1190. i += len;
  1191. sprintf(result, "OK: src_max=%s", info->src_max);
  1192. return count;
  1193. }
  1194. if (!strcmp(name, "dstmac")) {
  1195. char *v = valstr;
  1196. unsigned char *m = info->dst_mac;
  1198. len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
  1199. if (len < 0)
  1200. return len;
  1201. memset(valstr, 0, sizeof(valstr));
  1202. copy_from_user(valstr, &user_buffer[i], len);
  1203. i += len;
  1205. for(*m = 0;*v && m < info->dst_mac + 6; v++) {
  1206. if (*v >= '0' && *v <= '9') {
  1207. *m *= 16;
  1208. *m += *v - '0';
  1209. }
  1210. if (*v >= 'A' && *v <= 'F') {
  1211. *m *= 16;
  1212. *m += *v - 'A' + 10;
  1213. }
  1214. if (*v >= 'a' && *v <= 'f') {
  1215. *m *= 16;
  1216. *m += *v - 'a' + 10;
  1217. }
  1218. if (*v == ':') {
  1219. m++;
  1220. *m = 0;
  1221. }
  1222. }   
  1223. sprintf(result, "OK: dstmac");
  1224. return count;
  1225. }
  1226. if (!strcmp(name, "srcmac")) {
  1227. char *v = valstr;
  1228. unsigned char *m = info->src_mac;
  1230. len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
  1231. if (len < 0)
  1232. return len;
  1233. memset(valstr, 0, sizeof(valstr));
  1234. copy_from_user(valstr, &user_buffer[i], len);
  1235. i += len;
  1237. for(*m = 0;*v && m < info->src_mac + 6; v++) {
  1238. if (*v >= '0' && *v <= '9') {
  1239. *m *= 16;
  1240. *m += *v - '0';
  1241. }
  1242. if (*v >= 'A' && *v <= 'F') {
  1243. *m *= 16;
  1244. *m += *v - 'A' + 10;
  1245. }
  1246. if (*v >= 'a' && *v <= 'f') {
  1247. *m *= 16;
  1248. *m += *v - 'a' + 10;
  1249. }
  1250. if (*v == ':') {
  1251. m++;
  1252. *m = 0;
  1253. }
  1254. }   
  1255. sprintf(result, "OK: srcmac");
  1256. return count;
  1257. }
  1259. if (!strcmp(name, "inject") || !strcmp(name, "start")) {
  1260. MOD_INC_USE_COUNT;
  1261.                 if (info->busy) {
  1262.                         strcpy(info->result, "Already running...n");
  1263.                 }
  1264.                 else {
  1265.                         info->busy = 1;
  1266.                         strcpy(info->result, "Starting");
  1267.                         inject(info);
  1268.                         info->busy = 0;
  1269.                 }
  1270. MOD_DEC_USE_COUNT;
  1271. return count;
  1272. }
  1274. sprintf(info->result, "No such parameter "%s"", name);
  1275. return -EINVAL;
  1276. }
  1279. int create_proc_dir(void)
  1280. {
  1281.         int     len;
  1282.         /*  does proc_dir already exists */
  1283.         len = strlen(PG_PROC_DIR);
  1285.         for (proc_dir = proc_net->subdir; proc_dir;
  1286.              proc_dir=proc_dir->next) {
  1287.                 if ((proc_dir->namelen == len) &&
  1288.                     (! memcmp(proc_dir->name, PG_PROC_DIR, len)))
  1289.                         break;
  1290.         }
  1291.         if (!proc_dir)
  1292.                 proc_dir = create_proc_entry(PG_PROC_DIR, S_IFDIR, proc_net);
  1293.         if (!proc_dir) return -ENODEV;
  1294.         return 1;
  1295. }
  1297. int remove_proc_dir(void)
  1298. {
  1299.         remove_proc_entry(PG_PROC_DIR, proc_net);
  1300.         return 1;
  1301. }
  1303. static int __init init(void)
  1304. {
  1305.         int i;
  1306. printk(version);
  1307. cycles_calibrate();
  1308. if (cpu_speed == 0) {
  1309. printk("pktgen: Error: your machine does not have working cycle counter.n");
  1310. return -EINVAL;
  1311. }
  1313. create_proc_dir();
  1315.         for (i = 0; i<MAX_PKTGEN; i++) {
  1316.                 memset(&(pginfos[i]), 0, sizeof(pginfos[i]));
  1317.                 pginfos[i].pkt_size = ETH_ZLEN;
  1318.                 pginfos[i].nfrags = 0;
  1319.                 pginfos[i].clone_skb = clone_skb_d;
  1320.                 pginfos[i].ipg = ipg_d;
  1321.                 pginfos[i].count = count_d;
  1322.                 pginfos[i].sofar = 0;
  1323.                 pginfos[i].hh[12] = 0x08; /* fill in protocol.  Rest is filled in later. */
  1324.                 pginfos[i].hh[13] = 0x00;
  1325.                 pginfos[i].udp_src_min = 9; /* sink NULL */
  1326.                 pginfos[i].udp_src_max = 9;
  1327.                 pginfos[i].udp_dst_min = 9;
  1328.                 pginfos[i].udp_dst_max = 9;
  1329.                 
  1330.                 sprintf(pginfos[i].fname, "net/%s/pg%i", PG_PROC_DIR, i);
  1331.                 pginfos[i].proc_ent = create_proc_entry(pginfos[i].fname, 0600, 0);
  1332.                 if (!pginfos[i].proc_ent) {
  1333.                         printk("pktgen: Error: cannot create net/%s/pg procfs entry.n", PG_PROC_DIR);
  1334.                         goto cleanup_mem;
  1335.                 }
  1336.                 pginfos[i].proc_ent->read_proc = proc_read;
  1337.                 pginfos[i].proc_ent->write_proc = proc_write;
  1338.                 pginfos[i].proc_ent->data = (void*)(long)(i);
  1340.                 sprintf(pginfos[i].busy_fname, "net/%s/pg_busy%i",  PG_PROC_DIR, i);
  1341.                 pginfos[i].busy_proc_ent = create_proc_entry(pginfos[i].busy_fname, 0, 0);
  1342.                 if (!pginfos[i].busy_proc_ent) {
  1343.                         printk("pktgen: Error: cannot create net/%s/pg_busy procfs entry.n", PG_PROC_DIR);
  1344.                         goto cleanup_mem;
  1345.                 }
  1346.                 pginfos[i].busy_proc_ent->read_proc = proc_busy_read;
  1347.                 pginfos[i].busy_proc_ent->data = (void*)(long)(i);
  1348.         }
  1349.         return 0;
  1350.         
  1351. cleanup_mem:
  1352.         for (i = 0; i<MAX_PKTGEN; i++) {
  1353.                 if (strlen(pginfos[i].fname)) {
  1354.                         remove_proc_entry(pginfos[i].fname, NULL);
  1355.                 }
  1356.                 if (strlen(pginfos[i].busy_fname)) {
  1357.                         remove_proc_entry(pginfos[i].busy_fname, NULL);
  1358.                 }
  1359.         }
  1360. return -ENOMEM;
  1361. }
  1364. static void __exit cleanup(void)
  1365. {
  1366.         int i;
  1367.         for (i = 0; i<MAX_PKTGEN; i++) {
  1368.                 if (strlen(pginfos[i].fname)) {
  1369.                         remove_proc_entry(pginfos[i].fname, NULL);
  1370.                 }
  1371.                 if (strlen(pginfos[i].busy_fname)) {
  1372.                         remove_proc_entry(pginfos[i].busy_fname, NULL);
  1373.                 }
  1374.         }
  1375. remove_proc_dir();
  1376. }
  1378. module_init(init);
  1379. module_exit(cleanup);
  1381. MODULE_AUTHOR("Robert Olsson <robert.olsson@its.uu.se");
  1382. MODULE_DESCRIPTION("Packet Generator tool");
  1383. MODULE_LICENSE("GPL");
  1384. MODULE_PARM(count_d, "i");
  1385. MODULE_PARM(ipg_d, "i");
  1386. MODULE_PARM(cpu_speed, "i");
  1387. MODULE_PARM(clone_skb_d, "i");