1 /* 2 * Authors: 3 * Copyright 2001, 2002 by Robert Olsson <robert.olsson@its.uu.se> 4 * Uppsala University and 5 * Swedish University of Agricultural Sciences 6 * 7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 8 * Ben Greear <greearb@candelatech.com> 9 * Jens L��s <jens.laas@data.slu.se> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License 13 * as published by the Free Software Foundation; either version 14 * 2 of the License, or (at your option) any later version. 15 * 16 * 17 * A tool for loading the network with preconfigurated packets. 18 * The tool is implemented as a linux module. Parameters are output 19 * device, delay (to hard_xmit), number of packets, and whether 20 * to use multiple SKBs or just the same one. 21 * pktgen uses the installed interface's output routine. 22 * 23 * Additional hacking by: 24 * 25 * Jens.Laas@data.slu.se 26 * Improved by ANK. 010120. 27 * Improved by ANK even more. 010212. 28 * MAC address typo fixed. 010417 --ro 29 * Integrated. 020301 --DaveM 30 * Added multiskb option 020301 --DaveM 31 * Scaling of results. 020417--sigurdur@linpro.no 32 * Significant re-work of the module: 33 * * Convert to threaded model to more efficiently be able to transmit 34 * and receive on multiple interfaces at once. 35 * * Converted many counters to __u64 to allow longer runs. 36 * * Allow configuration of ranges, like min/max IP address, MACs, 37 * and UDP-ports, for both source and destination, and can 38 * set to use a random distribution or sequentially walk the range. 39 * * Can now change most values after starting. 40 * * Place 12-byte packet in UDP payload with magic number, 41 * sequence number, and timestamp. 42 * * Add receiver code that detects dropped pkts, re-ordered pkts, and 43 * latencies (with micro-second) precision. 44 * * Add IOCTL interface to easily get counters & configuration. 45 * --Ben Greear <greearb@candelatech.com> 46 * 47 * Renamed multiskb to clone_skb and cleaned up sending core for two distinct 48 * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0 49 * as a "fastpath" with a configurable number of clones after alloc's. 50 * clone_skb=0 means all packets are allocated this also means ranges time 51 * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100 52 * clones. 53 * 54 * Also moved to /proc/net/pktgen/ 55 * --ro 56 * 57 * Sept 10: Fixed threading/locking. Lots of bone-headed and more clever 58 * mistakes. Also merged in DaveM's patch in the -pre6 patch. 59 * --Ben Greear <greearb@candelatech.com> 60 * 61 * Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br) 62 * 63 * 64 * 021124 Finished major redesign and rewrite for new functionality. 65 * See Documentation/networking/pktgen.txt for how to use this. 66 * 67 * The new operation: 68 * For each CPU one thread/process is created at start. This process checks 69 * for running devices in the if_list and sends packets until count is 0 it 70 * also the thread checks the thread->control which is used for inter-process 71 * communication. controlling process "posts" operations to the threads this 72 * way. The if_lock should be possible to remove when add/rem_device is merged 73 * into this too. 74 * 75 * By design there should only be *one* "controlling" process. In practice 76 * multiple write accesses gives unpredictable result. Understood by "write" 77 * to /proc gives result code thats should be read be the "writer". 78 * For practical use this should be no problem. 79 * 80 * Note when adding devices to a specific CPU there good idea to also assign 81 * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU. 82 * --ro 83 * 84 * Fix refcount off by one if first packet fails, potential null deref, 85 * memleak 030710- KJP 86 * 87 * First "ranges" functionality for ipv6 030726 --ro 88 * 89 * Included flow support. 030802 ANK. 90 * 91 * Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org> 92 * 93 * Remove if fix from added Harald Welte <laforge@netfilter.org> 040419 94 * ia64 compilation fix from Aron Griffis <aron@hp.com> 040604 95 * 96 * New xmit() return, do_div and misc clean up by Stephen Hemminger 97 * <shemminger@osdl.org> 040923 98 * 99 * Randy Dunlap fixed u64 printk compiler waring 100 * 101 * Remove FCS from BW calculation. Lennert Buytenhek <buytenh@wantstofly.org> 102 * New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213 103 * 104 * Corrections from Nikolai Malykh (nmalykh@bilim.com) 105 * Removed unused flags F_SET_SRCMAC & F_SET_SRCIP 041230 106 * 107 * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com> 108 * 050103 109 * 110 * MPLS support by Steven Whitehouse <steve@chygwyn.com> 111 * 112 * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com> 113 * 114 */ 115 #include <linux/sys.h> 116 #include <linux/types.h> 117 #include <linux/module.h> 118 #include <linux/moduleparam.h> 119 #include <linux/kernel.h> 120 #include <linux/smp_lock.h> 121 #include <linux/mutex.h> 122 #include <linux/sched.h> 123 #include <linux/slab.h> 124 #include <linux/vmalloc.h> 125 #include <linux/unistd.h> 126 #include <linux/string.h> 127 #include <linux/ptrace.h> 128 #include <linux/errno.h> 129 #include <linux/ioport.h> 130 #include <linux/interrupt.h> 131 #include <linux/capability.h> 132 #include <linux/freezer.h> 133 #include <linux/delay.h> 134 #include <linux/timer.h> 135 #include <linux/list.h> 136 #include <linux/init.h> 137 #include <linux/skbuff.h> 138 #include <linux/netdevice.h> 139 #include <linux/inet.h> 140 #include <linux/inetdevice.h> 141 #include <linux/rtnetlink.h> 142 #include <linux/if_arp.h> 143 #include <linux/if_vlan.h> 144 #include <linux/in.h> 145 #include <linux/ip.h> 146 #include <linux/ipv6.h> 147 #include <linux/udp.h> 148 #include <linux/proc_fs.h> 149 #include <linux/seq_file.h> 150 #include <linux/wait.h> 151 #include <linux/etherdevice.h> 152 #include <linux/kthread.h> 153 #include <net/checksum.h> 154 #include <net/ipv6.h> 155 #include <net/addrconf.h> 156 #include <asm/byteorder.h> 157 #include <linux/rcupdate.h> 158 #include <asm/bitops.h> 159 #include <asm/io.h> 160 #include <asm/dma.h> 161 #include <asm/uaccess.h> 162 #include <asm/div64.h> /* do_div */ 163 #include <asm/timex.h> 164 165 #define VERSION "pktgen v2.68: Packet Generator for packet performance testing.\n" 166 167 /* The buckets are exponential in 'width' */ 168 #define LAT_BUCKETS_MAX 32 169 #define IP_NAME_SZ 32 170 #define MAX_MPLS_LABELS 16 /* This is the max label stack depth */ 171 #define MPLS_STACK_BOTTOM htonl(0x00000100) 172 173 /* Device flag bits */ 174 #define F_IPSRC_RND (1<<0) /* IP-Src Random */ 175 #define F_IPDST_RND (1<<1) /* IP-Dst Random */ 176 #define F_UDPSRC_RND (1<<2) /* UDP-Src Random */ 177 #define F_UDPDST_RND (1<<3) /* UDP-Dst Random */ 178 #define F_MACSRC_RND (1<<4) /* MAC-Src Random */ 179 #define F_MACDST_RND (1<<5) /* MAC-Dst Random */ 180 #define F_TXSIZE_RND (1<<6) /* Transmit size is random */ 181 #define F_IPV6 (1<<7) /* Interface in IPV6 Mode */ 182 #define F_MPLS_RND (1<<8) /* Random MPLS labels */ 183 #define F_VID_RND (1<<9) /* Random VLAN ID */ 184 #define F_SVID_RND (1<<10) /* Random SVLAN ID */ 185 186 /* Thread control flag bits */ 187 #define T_TERMINATE (1<<0) 188 #define T_STOP (1<<1) /* Stop run */ 189 #define T_RUN (1<<2) /* Start run */ 190 #define T_REMDEVALL (1<<3) /* Remove all devs */ 191 #define T_REMDEV (1<<4) /* Remove one dev */ 192 193 /* If lock -- can be removed after some work */ 194 #define if_lock(t) spin_lock(&(t->if_lock)); 195 #define if_unlock(t) spin_unlock(&(t->if_lock)); 196 197 /* Used to help with determining the pkts on receive */ 198 #define PKTGEN_MAGIC 0xbe9be955 199 #define PG_PROC_DIR "pktgen" 200 #define PGCTRL "pgctrl" 201 static struct proc_dir_entry *pg_proc_dir = NULL; 202 203 #define MAX_CFLOWS 65536 204 205 #define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4) 206 #define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4) 207 208 struct flow_state { 209 __be32 cur_daddr; 210 int count; 211 }; 212 213 struct pktgen_dev { 214 /* 215 * Try to keep frequent/infrequent used vars. separated. 216 */ 217 struct proc_dir_entry *entry; /* proc file */ 218 struct pktgen_thread *pg_thread;/* the owner */ 219 struct list_head list; /* Used for chaining in the thread's run-queue */ 220 221 int running; /* if this changes to false, the test will stop */ 222 223 /* If min != max, then we will either do a linear iteration, or 224 * we will do a random selection from within the range. 225 */ 226 __u32 flags; 227 int removal_mark; /* non-zero => the device is marked for 228 * removal by worker thread */ 229 230 int min_pkt_size; /* = ETH_ZLEN; */ 231 int max_pkt_size; /* = ETH_ZLEN; */ 232 int nfrags; 233 __u32 delay_us; /* Default delay */ 234 __u32 delay_ns; 235 __u64 count; /* Default No packets to send */ 236 __u64 sofar; /* How many pkts we've sent so far */ 237 __u64 tx_bytes; /* How many bytes we've transmitted */ 238 __u64 errors; /* Errors when trying to transmit, pkts will be re-sent */ 239 240 /* runtime counters relating to clone_skb */ 241 __u64 next_tx_us; /* timestamp of when to tx next */ 242 __u32 next_tx_ns; 243 244 __u64 allocated_skbs; 245 __u32 clone_count; 246 int last_ok; /* Was last skb sent? 247 * Or a failed transmit of some sort? This will keep 248 * sequence numbers in order, for example. 249 */ 250 __u64 started_at; /* micro-seconds */ 251 __u64 stopped_at; /* micro-seconds */ 252 __u64 idle_acc; /* micro-seconds */ 253 __u32 seq_num; 254 255 int clone_skb; /* Use multiple SKBs during packet gen. If this number 256 * is greater than 1, then that many copies of the same 257 * packet will be sent before a new packet is allocated. 258 * For instance, if you want to send 1024 identical packets 259 * before creating a new packet, set clone_skb to 1024. 260 */ 261 262 char dst_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */ 263 char dst_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */ 264 char src_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */ 265 char src_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */ 266 267 struct in6_addr in6_saddr; 268 struct in6_addr in6_daddr; 269 struct in6_addr cur_in6_daddr; 270 struct in6_addr cur_in6_saddr; 271 /* For ranges */ 272 struct in6_addr min_in6_daddr; 273 struct in6_addr max_in6_daddr; 274 struct in6_addr min_in6_saddr; 275 struct in6_addr max_in6_saddr; 276 277 /* If we're doing ranges, random or incremental, then this 278 * defines the min/max for those ranges. 279 */ 280 __be32 saddr_min; /* inclusive, source IP address */ 281 __be32 saddr_max; /* exclusive, source IP address */ 282 __be32 daddr_min; /* inclusive, dest IP address */ 283 __be32 daddr_max; /* exclusive, dest IP address */ 284 285 __u16 udp_src_min; /* inclusive, source UDP port */ 286 __u16 udp_src_max; /* exclusive, source UDP port */ 287 __u16 udp_dst_min; /* inclusive, dest UDP port */ 288 __u16 udp_dst_max; /* exclusive, dest UDP port */ 289 290 /* DSCP + ECN */ 291 __u8 tos; /* six most significant bits of (former) IPv4 TOS are for dscp codepoint */ 292 __u8 traffic_class; /* ditto for the (former) Traffic Class in IPv6 (see RFC 3260, sec. 4) */ 293 294 /* MPLS */ 295 unsigned nr_labels; /* Depth of stack, 0 = no MPLS */ 296 __be32 labels[MAX_MPLS_LABELS]; 297 298 /* VLAN/SVLAN (802.1Q/Q-in-Q) */ 299 __u8 vlan_p; 300 __u8 vlan_cfi; 301 __u16 vlan_id; /* 0xffff means no vlan tag */ 302 303 __u8 svlan_p; 304 __u8 svlan_cfi; 305 __u16 svlan_id; /* 0xffff means no svlan tag */ 306 307 __u32 src_mac_count; /* How many MACs to iterate through */ 308 __u32 dst_mac_count; /* How many MACs to iterate through */ 309 310 unsigned char dst_mac[ETH_ALEN]; 311 unsigned char src_mac[ETH_ALEN]; 312 313 __u32 cur_dst_mac_offset; 314 __u32 cur_src_mac_offset; 315 __be32 cur_saddr; 316 __be32 cur_daddr; 317 __u16 cur_udp_dst; 318 __u16 cur_udp_src; 319 __u32 cur_pkt_size; 320 321 __u8 hh[14]; 322 /* = { 323 0x00, 0x80, 0xC8, 0x79, 0xB3, 0xCB, 324 325 We fill in SRC address later 326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 327 0x08, 0x00 328 }; 329 */ 330 __u16 pad; /* pad out the hh struct to an even 16 bytes */ 331 332 struct sk_buff *skb; /* skb we are to transmit next, mainly used for when we 333 * are transmitting the same one multiple times 334 */ 335 struct net_device *odev; /* The out-going device. Note that the device should 336 * have it's pg_info pointer pointing back to this 337 * device. This will be set when the user specifies 338 * the out-going device name (not when the inject is 339 * started as it used to do.) 340 */ 341 struct flow_state *flows; 342 unsigned cflows; /* Concurrent flows (config) */ 343 unsigned lflow; /* Flow length (config) */ 344 unsigned nflows; /* accumulated flows (stats) */ 345 346 char result[512]; 347 }; 348 349 struct pktgen_hdr { 350 __be32 pgh_magic; 351 __be32 seq_num; 352 __be32 tv_sec; 353 __be32 tv_usec; 354 }; 355 356 struct pktgen_thread { 357 spinlock_t if_lock; 358 struct list_head if_list; /* All device here */ 359 struct list_head th_list; 360 struct task_struct *tsk; 361 char result[512]; 362 u32 max_before_softirq; /* We'll call do_softirq to prevent starvation. */ 363 364 /* Field for thread to receive "posted" events terminate, stop ifs etc. */ 365 366 u32 control; 367 int pid; 368 int cpu; 369 370 wait_queue_head_t queue; 371 }; 372 373 #define REMOVE 1 374 #define FIND 0 375 376 /* This code works around the fact that do_div cannot handle two 64-bit 377 numbers, and regular 64-bit division doesn't work on x86 kernels. 378 --Ben 379 */ 380 381 #define PG_DIV 0 382 383 /* This was emailed to LMKL by: Chris Caputo <ccaputo@alt.net> 384 * Function copied/adapted/optimized from: 385 * 386 * nemesis.sourceforge.net/browse/lib/static/intmath/ix86/intmath.c.html 387 * 388 * Copyright 1994, University of Cambridge Computer Laboratory 389 * All Rights Reserved. 390 * 391 */ 392 static inline s64 divremdi3(s64 x, s64 y, int type) 393 { 394 u64 a = (x < 0) ? -x : x; 395 u64 b = (y < 0) ? -y : y; 396 u64 res = 0, d = 1; 397 398 if (b > 0) { 399 while (b < a) { 400 b <<= 1; 401 d <<= 1; 402 } 403 } 404 405 do { 406 if (a >= b) { 407 a -= b; 408 res += d; 409 } 410 b >>= 1; 411 d >>= 1; 412 } 413 while (d); 414 415 if (PG_DIV == type) { 416 return (((x ^ y) & (1ll << 63)) == 0) ? res : -(s64) res; 417 } else { 418 return ((x & (1ll << 63)) == 0) ? a : -(s64) a; 419 } 420 } 421 422 /* End of hacks to deal with 64-bit math on x86 */ 423 424 /** Convert to milliseconds */ 425 static inline __u64 tv_to_ms(const struct timeval *tv) 426 { 427 __u64 ms = tv->tv_usec / 1000; 428 ms += (__u64) tv->tv_sec * (__u64) 1000; 429 return ms; 430 } 431 432 /** Convert to micro-seconds */ 433 static inline __u64 tv_to_us(const struct timeval *tv) 434 { 435 __u64 us = tv->tv_usec; 436 us += (__u64) tv->tv_sec * (__u64) 1000000; 437 return us; 438 } 439 440 static inline __u64 pg_div(__u64 n, __u32 base) 441 { 442 __u64 tmp = n; 443 do_div(tmp, base); 444 /* printk("pktgen: pg_div, n: %llu base: %d rv: %llu\n", 445 n, base, tmp); */ 446 return tmp; 447 } 448 449 static inline __u64 pg_div64(__u64 n, __u64 base) 450 { 451 __u64 tmp = n; 452 /* 453 * How do we know if the architecture we are running on 454 * supports division with 64 bit base? 455 * 456 */ 457 #if defined(__sparc_v9__) || defined(__powerpc64__) || defined(__alpha__) || defined(__x86_64__) || defined(__ia64__) 458 459 do_div(tmp, base); 460 #else 461 tmp = divremdi3(n, base, PG_DIV); 462 #endif 463 return tmp; 464 } 465 466 static inline __u64 getCurMs(void) 467 { 468 struct timeval tv; 469 do_gettimeofday(&tv); 470 return tv_to_ms(&tv); 471 } 472 473 static inline __u64 getCurUs(void) 474 { 475 struct timeval tv; 476 do_gettimeofday(&tv); 477 return tv_to_us(&tv); 478 } 479 480 static inline __u64 tv_diff(const struct timeval *a, const struct timeval *b) 481 { 482 return tv_to_us(a) - tv_to_us(b); 483 } 484 485 /* old include end */ 486 487 static char version[] __initdata = VERSION; 488 489 static int pktgen_remove_device(struct pktgen_thread *t, struct pktgen_dev *i); 490 static int pktgen_add_device(struct pktgen_thread *t, const char *ifname); 491 static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t, 492 const char *ifname); 493 static int pktgen_device_event(struct notifier_block *, unsigned long, void *); 494 static void pktgen_run_all_threads(void); 495 static void pktgen_stop_all_threads_ifs(void); 496 static int pktgen_stop_device(struct pktgen_dev *pkt_dev); 497 static void pktgen_stop(struct pktgen_thread *t); 498 static void pktgen_clear_counters(struct pktgen_dev *pkt_dev); 499 500 static unsigned int scan_ip6(const char *s, char ip[16]); 501 static unsigned int fmt_ip6(char *s, const char ip[16]); 502 503 /* Module parameters, defaults. */ 504 static int pg_count_d = 1000; /* 1000 pkts by default */ 505 static int pg_delay_d; 506 static int pg_clone_skb_d; 507 static int debug; 508 509 static DEFINE_MUTEX(pktgen_thread_lock); 510 static LIST_HEAD(pktgen_threads); 511 512 static struct notifier_block pktgen_notifier_block = { 513 .notifier_call = pktgen_device_event, 514 }; 515 516 /* 517 * /proc handling functions 518 * 519 */ 520 521 static int pgctrl_show(struct seq_file *seq, void *v) 522 { 523 seq_puts(seq, VERSION); 524 return 0; 525 } 526 527 static ssize_t pgctrl_write(struct file *file, const char __user * buf, 528 size_t count, loff_t * ppos) 529 { 530 int err = 0; 531 char data[128]; 532 533 if (!capable(CAP_NET_ADMIN)) { 534 err = -EPERM; 535 goto out; 536 } 537 538 if (count > sizeof(data)) 539 count = sizeof(data); 540 541 if (copy_from_user(data, buf, count)) { 542 err = -EFAULT; 543 goto out; 544 } 545 data[count - 1] = 0; /* Make string */ 546 547 if (!strcmp(data, "stop")) 548 pktgen_stop_all_threads_ifs(); 549 550 else if (!strcmp(data, "start")) 551 pktgen_run_all_threads(); 552 553 else 554 printk("pktgen: Unknown command: %s\n", data); 555 556 err = count; 557 558 out: 559 return err; 560 } 561 562 static int pgctrl_open(struct inode *inode, struct file *file) 563 { 564 return single_open(file, pgctrl_show, PDE(inode)->data); 565 } 566 567 static const struct file_operations pktgen_fops = { 568 .owner = THIS_MODULE, 569 .open = pgctrl_open, 570 .read = seq_read, 571 .llseek = seq_lseek, 572 .write = pgctrl_write, 573 .release = single_release, 574 }; 575 576 static int pktgen_if_show(struct seq_file *seq, void *v) 577 { 578 int i; 579 struct pktgen_dev *pkt_dev = seq->private; 580 __u64 sa; 581 __u64 stopped; 582 __u64 now = getCurUs(); 583 584 seq_printf(seq, 585 "Params: count %llu min_pkt_size: %u max_pkt_size: %u\n", 586 (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size, 587 pkt_dev->max_pkt_size); 588 589 seq_printf(seq, 590 " frags: %d delay: %u clone_skb: %d ifname: %s\n", 591 pkt_dev->nfrags, 592 1000 * pkt_dev->delay_us + pkt_dev->delay_ns, 593 pkt_dev->clone_skb, pkt_dev->odev->name); 594 595 seq_printf(seq, " flows: %u flowlen: %u\n", pkt_dev->cflows, 596 pkt_dev->lflow); 597 598 if (pkt_dev->flags & F_IPV6) { 599 char b1[128], b2[128], b3[128]; 600 fmt_ip6(b1, pkt_dev->in6_saddr.s6_addr); 601 fmt_ip6(b2, pkt_dev->min_in6_saddr.s6_addr); 602 fmt_ip6(b3, pkt_dev->max_in6_saddr.s6_addr); 603 seq_printf(seq, 604 " saddr: %s min_saddr: %s max_saddr: %s\n", b1, 605 b2, b3); 606 607 fmt_ip6(b1, pkt_dev->in6_daddr.s6_addr); 608 fmt_ip6(b2, pkt_dev->min_in6_daddr.s6_addr); 609 fmt_ip6(b3, pkt_dev->max_in6_daddr.s6_addr); 610 seq_printf(seq, 611 " daddr: %s min_daddr: %s max_daddr: %s\n", b1, 612 b2, b3); 613 614 } else 615 seq_printf(seq, 616 " dst_min: %s dst_max: %s\n src_min: %s src_max: %s\n", 617 pkt_dev->dst_min, pkt_dev->dst_max, pkt_dev->src_min, 618 pkt_dev->src_max); 619 620 seq_puts(seq, " src_mac: "); 621 622 if (is_zero_ether_addr(pkt_dev->src_mac)) 623 for (i = 0; i < 6; i++) 624 seq_printf(seq, "%02X%s", pkt_dev->odev->dev_addr[i], 625 i == 5 ? " " : ":"); 626 else 627 for (i = 0; i < 6; i++) 628 seq_printf(seq, "%02X%s", pkt_dev->src_mac[i], 629 i == 5 ? " " : ":"); 630 631 seq_printf(seq, "dst_mac: "); 632 for (i = 0; i < 6; i++) 633 seq_printf(seq, "%02X%s", pkt_dev->dst_mac[i], 634 i == 5 ? "\n" : ":"); 635 636 seq_printf(seq, 637 " udp_src_min: %d udp_src_max: %d udp_dst_min: %d udp_dst_max: %d\n", 638 pkt_dev->udp_src_min, pkt_dev->udp_src_max, 639 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max); 640 641 seq_printf(seq, 642 " src_mac_count: %d dst_mac_count: %d\n", 643 pkt_dev->src_mac_count, pkt_dev->dst_mac_count); 644 645 if (pkt_dev->nr_labels) { 646 unsigned i; 647 seq_printf(seq, " mpls: "); 648 for (i = 0; i < pkt_dev->nr_labels; i++) 649 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]), 650 i == pkt_dev->nr_labels-1 ? "\n" : ", "); 651 } 652 653 if (pkt_dev->vlan_id != 0xffff) { 654 seq_printf(seq, " vlan_id: %u vlan_p: %u vlan_cfi: %u\n", 655 pkt_dev->vlan_id, pkt_dev->vlan_p, pkt_dev->vlan_cfi); 656 } 657 658 if (pkt_dev->svlan_id != 0xffff) { 659 seq_printf(seq, " svlan_id: %u vlan_p: %u vlan_cfi: %u\n", 660 pkt_dev->svlan_id, pkt_dev->svlan_p, pkt_dev->svlan_cfi); 661 } 662 663 if (pkt_dev->tos) { 664 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos); 665 } 666 667 if (pkt_dev->traffic_class) { 668 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class); 669 } 670 671 seq_printf(seq, " Flags: "); 672 673 if (pkt_dev->flags & F_IPV6) 674 seq_printf(seq, "IPV6 "); 675 676 if (pkt_dev->flags & F_IPSRC_RND) 677 seq_printf(seq, "IPSRC_RND "); 678 679 if (pkt_dev->flags & F_IPDST_RND) 680 seq_printf(seq, "IPDST_RND "); 681 682 if (pkt_dev->flags & F_TXSIZE_RND) 683 seq_printf(seq, "TXSIZE_RND "); 684 685 if (pkt_dev->flags & F_UDPSRC_RND) 686 seq_printf(seq, "UDPSRC_RND "); 687 688 if (pkt_dev->flags & F_UDPDST_RND) 689 seq_printf(seq, "UDPDST_RND "); 690 691 if (pkt_dev->flags & F_MPLS_RND) 692 seq_printf(seq, "MPLS_RND "); 693 694 if (pkt_dev->flags & F_MACSRC_RND) 695 seq_printf(seq, "MACSRC_RND "); 696 697 if (pkt_dev->flags & F_MACDST_RND) 698 seq_printf(seq, "MACDST_RND "); 699 700 if (pkt_dev->flags & F_VID_RND) 701 seq_printf(seq, "VID_RND "); 702 703 if (pkt_dev->flags & F_SVID_RND) 704 seq_printf(seq, "SVID_RND "); 705 706 seq_puts(seq, "\n"); 707 708 sa = pkt_dev->started_at; 709 stopped = pkt_dev->stopped_at; 710 if (pkt_dev->running) 711 stopped = now; /* not really stopped, more like last-running-at */ 712 713 seq_printf(seq, 714 "Current:\n pkts-sofar: %llu errors: %llu\n started: %lluus stopped: %lluus idle: %lluus\n", 715 (unsigned long long)pkt_dev->sofar, 716 (unsigned long long)pkt_dev->errors, (unsigned long long)sa, 717 (unsigned long long)stopped, 718 (unsigned long long)pkt_dev->idle_acc); 719 720 seq_printf(seq, 721 " seq_num: %d cur_dst_mac_offset: %d cur_src_mac_offset: %d\n", 722 pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset, 723 pkt_dev->cur_src_mac_offset); 724 725 if (pkt_dev->flags & F_IPV6) { 726 char b1[128], b2[128]; 727 fmt_ip6(b1, pkt_dev->cur_in6_daddr.s6_addr); 728 fmt_ip6(b2, pkt_dev->cur_in6_saddr.s6_addr); 729 seq_printf(seq, " cur_saddr: %s cur_daddr: %s\n", b2, b1); 730 } else 731 seq_printf(seq, " cur_saddr: 0x%x cur_daddr: 0x%x\n", 732 pkt_dev->cur_saddr, pkt_dev->cur_daddr); 733 734 seq_printf(seq, " cur_udp_dst: %d cur_udp_src: %d\n", 735 pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src); 736 737 seq_printf(seq, " flows: %u\n", pkt_dev->nflows); 738 739 if (pkt_dev->result[0]) 740 seq_printf(seq, "Result: %s\n", pkt_dev->result); 741 else 742 seq_printf(seq, "Result: Idle\n"); 743 744 return 0; 745 } 746 747 748 static int hex32_arg(const char __user *user_buffer, unsigned long maxlen, __u32 *num) 749 { 750 int i = 0; 751 *num = 0; 752 753 for (; i < maxlen; i++) { 754 char c; 755 *num <<= 4; 756 if (get_user(c, &user_buffer[i])) 757 return -EFAULT; 758 if ((c >= '0') && (c <= '9')) 759 *num |= c - '0'; 760 else if ((c >= 'a') && (c <= 'f')) 761 *num |= c - 'a' + 10; 762 else if ((c >= 'A') && (c <= 'F')) 763 *num |= c - 'A' + 10; 764 else 765 break; 766 } 767 return i; 768 } 769 770 static int count_trail_chars(const char __user * user_buffer, 771 unsigned int maxlen) 772 { 773 int i; 774 775 for (i = 0; i < maxlen; i++) { 776 char c; 777 if (get_user(c, &user_buffer[i])) 778 return -EFAULT; 779 switch (c) { 780 case '\"': 781 case '\n': 782 case '\r': 783 case '\t': 784 case ' ': 785 case '=': 786 break; 787 default: 788 goto done; 789 } 790 } 791 done: 792 return i; 793 } 794 795 static unsigned long num_arg(const char __user * user_buffer, 796 unsigned long maxlen, unsigned long *num) 797 { 798 int i = 0; 799 *num = 0; 800 801 for (; i < maxlen; i++) { 802 char c; 803 if (get_user(c, &user_buffer[i])) 804 return -EFAULT; 805 if ((c >= '0') && (c <= '9')) { 806 *num *= 10; 807 *num += c - '0'; 808 } else 809 break; 810 } 811 return i; 812 } 813 814 static int strn_len(const char __user * user_buffer, unsigned int maxlen) 815 { 816 int i = 0; 817 818 for (; i < maxlen; i++) { 819 char c; 820 if (get_user(c, &user_buffer[i])) 821 return -EFAULT; 822 switch (c) { 823 case '\"': 824 case '\n': 825 case '\r': 826 case '\t': 827 case ' ': 828 goto done_str; 829 break; 830 default: 831 break; 832 } 833 } 834 done_str: 835 return i; 836 } 837 838 static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev) 839 { 840 unsigned n = 0; 841 char c; 842 ssize_t i = 0; 843 int len; 844 845 pkt_dev->nr_labels = 0; 846 do { 847 __u32 tmp; 848 len = hex32_arg(&buffer[i], 8, &tmp); 849 if (len <= 0) 850 return len; 851 pkt_dev->labels[n] = htonl(tmp); 852 if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM) 853 pkt_dev->flags |= F_MPLS_RND; 854 i += len; 855 if (get_user(c, &buffer[i])) 856 return -EFAULT; 857 i++; 858 n++; 859 if (n >= MAX_MPLS_LABELS) 860 return -E2BIG; 861 } while (c == ','); 862 863 pkt_dev->nr_labels = n; 864 return i; 865 } 866 867 static ssize_t pktgen_if_write(struct file *file, 868 const char __user * user_buffer, size_t count, 869 loff_t * offset) 870 { 871 struct seq_file *seq = (struct seq_file *)file->private_data; 872 struct pktgen_dev *pkt_dev = seq->private; 873 int i = 0, max, len; 874 char name[16], valstr[32]; 875 unsigned long value = 0; 876 char *pg_result = NULL; 877 int tmp = 0; 878 char buf[128]; 879 880 pg_result = &(pkt_dev->result[0]); 881 882 if (count < 1) { 883 printk("pktgen: wrong command format\n"); 884 return -EINVAL; 885 } 886 887 max = count - i; 888 tmp = count_trail_chars(&user_buffer[i], max); 889 if (tmp < 0) { 890 printk("pktgen: illegal format\n"); 891 return tmp; 892 } 893 i += tmp; 894 895 /* Read variable name */ 896 897 len = strn_len(&user_buffer[i], sizeof(name) - 1); 898 if (len < 0) { 899 return len; 900 } 901 memset(name, 0, sizeof(name)); 902 if (copy_from_user(name, &user_buffer[i], len)) 903 return -EFAULT; 904 i += len; 905 906 max = count - i; 907 len = count_trail_chars(&user_buffer[i], max); 908 if (len < 0) 909 return len; 910 911 i += len; 912 913 if (debug) { 914 char tb[count + 1]; 915 if (copy_from_user(tb, user_buffer, count)) 916 return -EFAULT; 917 tb[count] = 0; 918 printk("pktgen: %s,%lu buffer -:%s:-\n", name, 919 (unsigned long)count, tb); 920 } 921 922 if (!strcmp(name, "min_pkt_size")) { 923 len = num_arg(&user_buffer[i], 10, &value); 924 if (len < 0) { 925 return len; 926 } 927 i += len; 928 if (value < 14 + 20 + 8) 929 value = 14 + 20 + 8; 930 if (value != pkt_dev->min_pkt_size) { 931 pkt_dev->min_pkt_size = value; 932 pkt_dev->cur_pkt_size = value; 933 } 934 sprintf(pg_result, "OK: min_pkt_size=%u", 935 pkt_dev->min_pkt_size); 936 return count; 937 } 938 939 if (!strcmp(name, "max_pkt_size")) { 940 len = num_arg(&user_buffer[i], 10, &value); 941 if (len < 0) { 942 return len; 943 } 944 i += len; 945 if (value < 14 + 20 + 8) 946 value = 14 + 20 + 8; 947 if (value != pkt_dev->max_pkt_size) { 948 pkt_dev->max_pkt_size = value; 949 pkt_dev->cur_pkt_size = value; 950 } 951 sprintf(pg_result, "OK: max_pkt_size=%u", 952 pkt_dev->max_pkt_size); 953 return count; 954 } 955 956 /* Shortcut for min = max */ 957 958 if (!strcmp(name, "pkt_size")) { 959 len = num_arg(&user_buffer[i], 10, &value); 960 if (len < 0) { 961 return len; 962 } 963 i += len; 964 if (value < 14 + 20 + 8) 965 value = 14 + 20 + 8; 966 if (value != pkt_dev->min_pkt_size) { 967 pkt_dev->min_pkt_size = value; 968 pkt_dev->max_pkt_size = value; 969 pkt_dev->cur_pkt_size = value; 970 } 971 sprintf(pg_result, "OK: pkt_size=%u", pkt_dev->min_pkt_size); 972 return count; 973 } 974 975 if (!strcmp(name, "debug")) { 976 len = num_arg(&user_buffer[i], 10, &value); 977 if (len < 0) { 978 return len; 979 } 980 i += len; 981 debug = value; 982 sprintf(pg_result, "OK: debug=%u", debug); 983 return count; 984 } 985 986 if (!strcmp(name, "frags")) { 987 len = num_arg(&user_buffer[i], 10, &value); 988 if (len < 0) { 989 return len; 990 } 991 i += len; 992 pkt_dev->nfrags = value; 993 sprintf(pg_result, "OK: frags=%u", pkt_dev->nfrags); 994 return count; 995 } 996 if (!strcmp(name, "delay")) { 997 len = num_arg(&user_buffer[i], 10, &value); 998 if (len < 0) { 999 return len; 1000 } 1001 i += len; 1002 if (value == 0x7FFFFFFF) { 1003 pkt_dev->delay_us = 0x7FFFFFFF; 1004 pkt_dev->delay_ns = 0; 1005 } else { 1006 pkt_dev->delay_us = value / 1000; 1007 pkt_dev->delay_ns = value % 1000; 1008 } 1009 sprintf(pg_result, "OK: delay=%u", 1010 1000 * pkt_dev->delay_us + pkt_dev->delay_ns); 1011 return count; 1012 } 1013 if (!strcmp(name, "udp_src_min")) { 1014 len = num_arg(&user_buffer[i], 10, &value); 1015 if (len < 0) { 1016 return len; 1017 } 1018 i += len; 1019 if (value != pkt_dev->udp_src_min) { 1020 pkt_dev->udp_src_min = value; 1021 pkt_dev->cur_udp_src = value; 1022 } 1023 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min); 1024 return count; 1025 } 1026 if (!strcmp(name, "udp_dst_min")) { 1027 len = num_arg(&user_buffer[i], 10, &value); 1028 if (len < 0) { 1029 return len; 1030 } 1031 i += len; 1032 if (value != pkt_dev->udp_dst_min) { 1033 pkt_dev->udp_dst_min = value; 1034 pkt_dev->cur_udp_dst = value; 1035 } 1036 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min); 1037 return count; 1038 } 1039 if (!strcmp(name, "udp_src_max")) { 1040 len = num_arg(&user_buffer[i], 10, &value); 1041 if (len < 0) { 1042 return len; 1043 } 1044 i += len; 1045 if (value != pkt_dev->udp_src_max) { 1046 pkt_dev->udp_src_max = value; 1047 pkt_dev->cur_udp_src = value; 1048 } 1049 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max); 1050 return count; 1051 } 1052 if (!strcmp(name, "udp_dst_max")) { 1053 len = num_arg(&user_buffer[i], 10, &value); 1054 if (len < 0) { 1055 return len; 1056 } 1057 i += len; 1058 if (value != pkt_dev->udp_dst_max) { 1059 pkt_dev->udp_dst_max = value; 1060 pkt_dev->cur_udp_dst = value; 1061 } 1062 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max); 1063 return count; 1064 } 1065 if (!strcmp(name, "clone_skb")) { 1066 len = num_arg(&user_buffer[i], 10, &value); 1067 if (len < 0) { 1068 return len; 1069 } 1070 i += len; 1071 pkt_dev->clone_skb = value; 1072 1073 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb); 1074 return count; 1075 } 1076 if (!strcmp(name, "count")) { 1077 len = num_arg(&user_buffer[i], 10, &value); 1078 if (len < 0) { 1079 return len; 1080 } 1081 i += len; 1082 pkt_dev->count = value; 1083 sprintf(pg_result, "OK: count=%llu", 1084 (unsigned long long)pkt_dev->count); 1085 return count; 1086 } 1087 if (!strcmp(name, "src_mac_count")) { 1088 len = num_arg(&user_buffer[i], 10, &value); 1089 if (len < 0) { 1090 return len; 1091 } 1092 i += len; 1093 if (pkt_dev->src_mac_count != value) { 1094 pkt_dev->src_mac_count = value; 1095 pkt_dev->cur_src_mac_offset = 0; 1096 } 1097 sprintf(pg_result, "OK: src_mac_count=%d", 1098 pkt_dev->src_mac_count); 1099 return count; 1100 } 1101 if (!strcmp(name, "dst_mac_count")) { 1102 len = num_arg(&user_buffer[i], 10, &value); 1103 if (len < 0) { 1104 return len; 1105 } 1106 i += len; 1107 if (pkt_dev->dst_mac_count != value) { 1108 pkt_dev->dst_mac_count = value; 1109 pkt_dev->cur_dst_mac_offset = 0; 1110 } 1111 sprintf(pg_result, "OK: dst_mac_count=%d", 1112 pkt_dev->dst_mac_count); 1113 return count; 1114 } 1115 if (!strcmp(name, "flag")) { 1116 char f[32]; 1117 memset(f, 0, 32); 1118 len = strn_len(&user_buffer[i], sizeof(f) - 1); 1119 if (len < 0) { 1120 return len; 1121 } 1122 if (copy_from_user(f, &user_buffer[i], len)) 1123 return -EFAULT; 1124 i += len; 1125 if (strcmp(f, "IPSRC_RND") == 0) 1126 pkt_dev->flags |= F_IPSRC_RND; 1127 1128 else if (strcmp(f, "!IPSRC_RND") == 0) 1129 pkt_dev->flags &= ~F_IPSRC_RND; 1130 1131 else if (strcmp(f, "TXSIZE_RND") == 0) 1132 pkt_dev->flags |= F_TXSIZE_RND; 1133 1134 else if (strcmp(f, "!TXSIZE_RND") == 0) 1135 pkt_dev->flags &= ~F_TXSIZE_RND; 1136 1137 else if (strcmp(f, "IPDST_RND") == 0) 1138 pkt_dev->flags |= F_IPDST_RND; 1139 1140 else if (strcmp(f, "!IPDST_RND") == 0) 1141 pkt_dev->flags &= ~F_IPDST_RND; 1142 1143 else if (strcmp(f, "UDPSRC_RND") == 0) 1144 pkt_dev->flags |= F_UDPSRC_RND; 1145 1146 else if (strcmp(f, "!UDPSRC_RND") == 0) 1147 pkt_dev->flags &= ~F_UDPSRC_RND; 1148 1149 else if (strcmp(f, "UDPDST_RND") == 0) 1150 pkt_dev->flags |= F_UDPDST_RND; 1151 1152 else if (strcmp(f, "!UDPDST_RND") == 0) 1153 pkt_dev->flags &= ~F_UDPDST_RND; 1154 1155 else if (strcmp(f, "MACSRC_RND") == 0) 1156 pkt_dev->flags |= F_MACSRC_RND; 1157 1158 else if (strcmp(f, "!MACSRC_RND") == 0) 1159 pkt_dev->flags &= ~F_MACSRC_RND; 1160 1161 else if (strcmp(f, "MACDST_RND") == 0) 1162 pkt_dev->flags |= F_MACDST_RND; 1163 1164 else if (strcmp(f, "!MACDST_RND") == 0) 1165 pkt_dev->flags &= ~F_MACDST_RND; 1166 1167 else if (strcmp(f, "MPLS_RND") == 0) 1168 pkt_dev->flags |= F_MPLS_RND; 1169 1170 else if (strcmp(f, "!MPLS_RND") == 0) 1171 pkt_dev->flags &= ~F_MPLS_RND; 1172 1173 else if (strcmp(f, "VID_RND") == 0) 1174 pkt_dev->flags |= F_VID_RND; 1175 1176 else if (strcmp(f, "!VID_RND") == 0) 1177 pkt_dev->flags &= ~F_VID_RND; 1178 1179 else if (strcmp(f, "SVID_RND") == 0) 1180 pkt_dev->flags |= F_SVID_RND; 1181 1182 else if (strcmp(f, "!SVID_RND") == 0) 1183 pkt_dev->flags &= ~F_SVID_RND; 1184 1185 else if (strcmp(f, "!IPV6") == 0) 1186 pkt_dev->flags &= ~F_IPV6; 1187 1188 else { 1189 sprintf(pg_result, 1190 "Flag -:%s:- unknown\nAvailable flags, (prepend ! to un-set flag):\n%s", 1191 f, 1192 "IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, " 1193 "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND\n"); 1194 return count; 1195 } 1196 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags); 1197 return count; 1198 } 1199 if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) { 1200 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_min) - 1); 1201 if (len < 0) { 1202 return len; 1203 } 1204 1205 if (copy_from_user(buf, &user_buffer[i], len)) 1206 return -EFAULT; 1207 buf[len] = 0; 1208 if (strcmp(buf, pkt_dev->dst_min) != 0) { 1209 memset(pkt_dev->dst_min, 0, sizeof(pkt_dev->dst_min)); 1210 strncpy(pkt_dev->dst_min, buf, len); 1211 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min); 1212 pkt_dev->cur_daddr = pkt_dev->daddr_min; 1213 } 1214 if (debug) 1215 printk("pktgen: dst_min set to: %s\n", 1216 pkt_dev->dst_min); 1217 i += len; 1218 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min); 1219 return count; 1220 } 1221 if (!strcmp(name, "dst_max")) { 1222 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_max) - 1); 1223 if (len < 0) { 1224 return len; 1225 } 1226 1227 if (copy_from_user(buf, &user_buffer[i], len)) 1228 return -EFAULT; 1229 1230 buf[len] = 0; 1231 if (strcmp(buf, pkt_dev->dst_max) != 0) { 1232 memset(pkt_dev->dst_max, 0, sizeof(pkt_dev->dst_max)); 1233 strncpy(pkt_dev->dst_max, buf, len); 1234 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max); 1235 pkt_dev->cur_daddr = pkt_dev->daddr_max; 1236 } 1237 if (debug) 1238 printk("pktgen: dst_max set to: %s\n", 1239 pkt_dev->dst_max); 1240 i += len; 1241 sprintf(pg_result, "OK: dst_max=%s", pkt_dev->dst_max); 1242 return count; 1243 } 1244 if (!strcmp(name, "dst6")) { 1245 len = strn_len(&user_buffer[i], sizeof(buf) - 1); 1246 if (len < 0) 1247 return len; 1248 1249 pkt_dev->flags |= F_IPV6; 1250 1251 if (copy_from_user(buf, &user_buffer[i], len)) 1252 return -EFAULT; 1253 buf[len] = 0; 1254 1255 scan_ip6(buf, pkt_dev->in6_daddr.s6_addr); 1256 fmt_ip6(buf, pkt_dev->in6_daddr.s6_addr); 1257 1258 ipv6_addr_copy(&pkt_dev->cur_in6_daddr, &pkt_dev->in6_daddr); 1259 1260 if (debug) 1261 printk("pktgen: dst6 set to: %s\n", buf); 1262 1263 i += len; 1264 sprintf(pg_result, "OK: dst6=%s", buf); 1265 return count; 1266 } 1267 if (!strcmp(name, "dst6_min")) { 1268 len = strn_len(&user_buffer[i], sizeof(buf) - 1); 1269 if (len < 0) 1270 return len; 1271 1272 pkt_dev->flags |= F_IPV6; 1273 1274 if (copy_from_user(buf, &user_buffer[i], len)) 1275 return -EFAULT; 1276 buf[len] = 0; 1277 1278 scan_ip6(buf, pkt_dev->min_in6_daddr.s6_addr); 1279 fmt_ip6(buf, pkt_dev->min_in6_daddr.s6_addr); 1280 1281 ipv6_addr_copy(&pkt_dev->cur_in6_daddr, 1282 &pkt_dev->min_in6_daddr); 1283 if (debug) 1284 printk("pktgen: dst6_min set to: %s\n", buf); 1285 1286 i += len; 1287 sprintf(pg_result, "OK: dst6_min=%s", buf); 1288 return count; 1289 } 1290 if (!strcmp(name, "dst6_max")) { 1291 len = strn_len(&user_buffer[i], sizeof(buf) - 1); 1292 if (len < 0) 1293 return len; 1294 1295 pkt_dev->flags |= F_IPV6; 1296 1297 if (copy_from_user(buf, &user_buffer[i], len)) 1298 return -EFAULT; 1299 buf[len] = 0; 1300 1301 scan_ip6(buf, pkt_dev->max_in6_daddr.s6_addr); 1302 fmt_ip6(buf, pkt_dev->max_in6_daddr.s6_addr); 1303 1304 if (debug) 1305 printk("pktgen: dst6_max set to: %s\n", buf); 1306 1307 i += len; 1308 sprintf(pg_result, "OK: dst6_max=%s", buf); 1309 return count; 1310 } 1311 if (!strcmp(name, "src6")) { 1312 len = strn_len(&user_buffer[i], sizeof(buf) - 1); 1313 if (len < 0) 1314 return len; 1315 1316 pkt_dev->flags |= F_IPV6; 1317 1318 if (copy_from_user(buf, &user_buffer[i], len)) 1319 return -EFAULT; 1320 buf[len] = 0; 1321 1322 scan_ip6(buf, pkt_dev->in6_saddr.s6_addr); 1323 fmt_ip6(buf, pkt_dev->in6_saddr.s6_addr); 1324 1325 ipv6_addr_copy(&pkt_dev->cur_in6_saddr, &pkt_dev->in6_saddr); 1326 1327 if (debug) 1328 printk("pktgen: src6 set to: %s\n", buf); 1329 1330 i += len; 1331 sprintf(pg_result, "OK: src6=%s", buf); 1332 return count; 1333 } 1334 if (!strcmp(name, "src_min")) { 1335 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_min) - 1); 1336 if (len < 0) { 1337 return len; 1338 } 1339 if (copy_from_user(buf, &user_buffer[i], len)) 1340 return -EFAULT; 1341 buf[len] = 0; 1342 if (strcmp(buf, pkt_dev->src_min) != 0) { 1343 memset(pkt_dev->src_min, 0, sizeof(pkt_dev->src_min)); 1344 strncpy(pkt_dev->src_min, buf, len); 1345 pkt_dev->saddr_min = in_aton(pkt_dev->src_min); 1346 pkt_dev->cur_saddr = pkt_dev->saddr_min; 1347 } 1348 if (debug) 1349 printk("pktgen: src_min set to: %s\n", 1350 pkt_dev->src_min); 1351 i += len; 1352 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min); 1353 return count; 1354 } 1355 if (!strcmp(name, "src_max")) { 1356 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_max) - 1); 1357 if (len < 0) { 1358 return len; 1359 } 1360 if (copy_from_user(buf, &user_buffer[i], len)) 1361 return -EFAULT; 1362 buf[len] = 0; 1363 if (strcmp(buf, pkt_dev->src_max) != 0) { 1364 memset(pkt_dev->src_max, 0, sizeof(pkt_dev->src_max)); 1365 strncpy(pkt_dev->src_max, buf, len); 1366 pkt_dev->saddr_max = in_aton(pkt_dev->src_max); 1367 pkt_dev->cur_saddr = pkt_dev->saddr_max; 1368 } 1369 if (debug) 1370 printk("pktgen: src_max set to: %s\n", 1371 pkt_dev->src_max); 1372 i += len; 1373 sprintf(pg_result, "OK: src_max=%s", pkt_dev->src_max); 1374 return count; 1375 } 1376 if (!strcmp(name, "dst_mac")) { 1377 char *v = valstr; 1378 unsigned char old_dmac[ETH_ALEN]; 1379 unsigned char *m = pkt_dev->dst_mac; 1380 memcpy(old_dmac, pkt_dev->dst_mac, ETH_ALEN); 1381 1382 len = strn_len(&user_buffer[i], sizeof(valstr) - 1); 1383 if (len < 0) { 1384 return len; 1385 } 1386 memset(valstr, 0, sizeof(valstr)); 1387 if (copy_from_user(valstr, &user_buffer[i], len)) 1388 return -EFAULT; 1389 i += len; 1390 1391 for (*m = 0; *v && m < pkt_dev->dst_mac + 6; v++) { 1392 if (*v >= '0' && *v <= '9') { 1393 *m *= 16; 1394 *m += *v - '0'; 1395 } 1396 if (*v >= 'A' && *v <= 'F') { 1397 *m *= 16; 1398 *m += *v - 'A' + 10; 1399 } 1400 if (*v >= 'a' && *v <= 'f') { 1401 *m *= 16; 1402 *m += *v - 'a' + 10; 1403 } 1404 if (*v == ':') { 1405 m++; 1406 *m = 0; 1407 } 1408 } 1409 1410 /* Set up Dest MAC */ 1411 if (compare_ether_addr(old_dmac, pkt_dev->dst_mac)) 1412 memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, ETH_ALEN); 1413 1414 sprintf(pg_result, "OK: dstmac"); 1415 return count; 1416 } 1417 if (!strcmp(name, "src_mac")) { 1418 char *v = valstr; 1419 unsigned char *m = pkt_dev->src_mac; 1420 1421 len = strn_len(&user_buffer[i], sizeof(valstr) - 1); 1422 if (len < 0) { 1423 return len; 1424 } 1425 memset(valstr, 0, sizeof(valstr)); 1426 if (copy_from_user(valstr, &user_buffer[i], len)) 1427 return -EFAULT; 1428 i += len; 1429 1430 for (*m = 0; *v && m < pkt_dev->src_mac + 6; v++) { 1431 if (*v >= '0' && *v <= '9') { 1432 *m *= 16; 1433 *m += *v - '0'; 1434 } 1435 if (*v >= 'A' && *v <= 'F') { 1436 *m *= 16; 1437 *m += *v - 'A' + 10; 1438 } 1439 if (*v >= 'a' && *v <= 'f') { 1440 *m *= 16; 1441 *m += *v - 'a' + 10; 1442 } 1443 if (*v == ':') { 1444 m++; 1445 *m = 0; 1446 } 1447 } 1448 1449 sprintf(pg_result, "OK: srcmac"); 1450 return count; 1451 } 1452 1453 if (!strcmp(name, "clear_counters")) { 1454 pktgen_clear_counters(pkt_dev); 1455 sprintf(pg_result, "OK: Clearing counters.\n"); 1456 return count; 1457 } 1458 1459 if (!strcmp(name, "flows")) { 1460 len = num_arg(&user_buffer[i], 10, &value); 1461 if (len < 0) { 1462 return len; 1463 } 1464 i += len; 1465 if (value > MAX_CFLOWS) 1466 value = MAX_CFLOWS; 1467 1468 pkt_dev->cflows = value; 1469 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows); 1470 return count; 1471 } 1472 1473 if (!strcmp(name, "flowlen")) { 1474 len = num_arg(&user_buffer[i], 10, &value); 1475 if (len < 0) { 1476 return len; 1477 } 1478 i += len; 1479 pkt_dev->lflow = value; 1480 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow); 1481 return count; 1482 } 1483 1484 if (!strcmp(name, "mpls")) { 1485 unsigned n, offset; 1486 len = get_labels(&user_buffer[i], pkt_dev); 1487 if (len < 0) { return len; } 1488 i += len; 1489 offset = sprintf(pg_result, "OK: mpls="); 1490 for (n = 0; n < pkt_dev->nr_labels; n++) 1491 offset += sprintf(pg_result + offset, 1492 "%08x%s", ntohl(pkt_dev->labels[n]), 1493 n == pkt_dev->nr_labels-1 ? "" : ","); 1494 1495 if (pkt_dev->nr_labels && pkt_dev->vlan_id != 0xffff) { 1496 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */ 1497 pkt_dev->svlan_id = 0xffff; 1498 1499 if (debug) 1500 printk("pktgen: VLAN/SVLAN auto turned off\n"); 1501 } 1502 return count; 1503 } 1504 1505 if (!strcmp(name, "vlan_id")) { 1506 len = num_arg(&user_buffer[i], 4, &value); 1507 if (len < 0) { 1508 return len; 1509 } 1510 i += len; 1511 if (value <= 4095) { 1512 pkt_dev->vlan_id = value; /* turn on VLAN */ 1513 1514 if (debug) 1515 printk("pktgen: VLAN turned on\n"); 1516 1517 if (debug && pkt_dev->nr_labels) 1518 printk("pktgen: MPLS auto turned off\n"); 1519 1520 pkt_dev->nr_labels = 0; /* turn off MPLS */ 1521 sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id); 1522 } else { 1523 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */ 1524 pkt_dev->svlan_id = 0xffff; 1525 1526 if (debug) 1527 printk("pktgen: VLAN/SVLAN turned off\n"); 1528 } 1529 return count; 1530 } 1531 1532 if (!strcmp(name, "vlan_p")) { 1533 len = num_arg(&user_buffer[i], 1, &value); 1534 if (len < 0) { 1535 return len; 1536 } 1537 i += len; 1538 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) { 1539 pkt_dev->vlan_p = value; 1540 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p); 1541 } else { 1542 sprintf(pg_result, "ERROR: vlan_p must be 0-7"); 1543 } 1544 return count; 1545 } 1546 1547 if (!strcmp(name, "vlan_cfi")) { 1548 len = num_arg(&user_buffer[i], 1, &value); 1549 if (len < 0) { 1550 return len; 1551 } 1552 i += len; 1553 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) { 1554 pkt_dev->vlan_cfi = value; 1555 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi); 1556 } else { 1557 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1"); 1558 } 1559 return count; 1560 } 1561 1562 if (!strcmp(name, "svlan_id")) { 1563 len = num_arg(&user_buffer[i], 4, &value); 1564 if (len < 0) { 1565 return len; 1566 } 1567 i += len; 1568 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) { 1569 pkt_dev->svlan_id = value; /* turn on SVLAN */ 1570 1571 if (debug) 1572 printk("pktgen: SVLAN turned on\n"); 1573 1574 if (debug && pkt_dev->nr_labels) 1575 printk("pktgen: MPLS auto turned off\n"); 1576 1577 pkt_dev->nr_labels = 0; /* turn off MPLS */ 1578 sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id); 1579 } else { 1580 pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */ 1581 pkt_dev->svlan_id = 0xffff; 1582 1583 if (debug) 1584 printk("pktgen: VLAN/SVLAN turned off\n"); 1585 } 1586 return count; 1587 } 1588 1589 if (!strcmp(name, "svlan_p")) { 1590 len = num_arg(&user_buffer[i], 1, &value); 1591 if (len < 0) { 1592 return len; 1593 } 1594 i += len; 1595 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) { 1596 pkt_dev->svlan_p = value; 1597 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p); 1598 } else { 1599 sprintf(pg_result, "ERROR: svlan_p must be 0-7"); 1600 } 1601 return count; 1602 } 1603 1604 if (!strcmp(name, "svlan_cfi")) { 1605 len = num_arg(&user_buffer[i], 1, &value); 1606 if (len < 0) { 1607 return len; 1608 } 1609 i += len; 1610 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) { 1611 pkt_dev->svlan_cfi = value; 1612 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi); 1613 } else { 1614 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1"); 1615 } 1616 return count; 1617 } 1618 1619 if (!strcmp(name, "tos")) { 1620 __u32 tmp_value = 0; 1621 len = hex32_arg(&user_buffer[i], 2, &tmp_value); 1622 if (len < 0) { 1623 return len; 1624 } 1625 i += len; 1626 if (len == 2) { 1627 pkt_dev->tos = tmp_value; 1628 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos); 1629 } else { 1630 sprintf(pg_result, "ERROR: tos must be 00-ff"); 1631 } 1632 return count; 1633 } 1634 1635 if (!strcmp(name, "traffic_class")) { 1636 __u32 tmp_value = 0; 1637 len = hex32_arg(&user_buffer[i], 2, &tmp_value); 1638 if (len < 0) { 1639 return len; 1640 } 1641 i += len; 1642 if (len == 2) { 1643 pkt_dev->traffic_class = tmp_value; 1644 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class); 1645 } else { 1646 sprintf(pg_result, "ERROR: traffic_class must be 00-ff"); 1647 } 1648 return count; 1649 } 1650 1651 sprintf(pkt_dev->result, "No such parameter \"%s\"", name); 1652 return -EINVAL; 1653 } 1654 1655 static int pktgen_if_open(struct inode *inode, struct file *file) 1656 { 1657 return single_open(file, pktgen_if_show, PDE(inode)->data); 1658 } 1659 1660 static const struct file_operations pktgen_if_fops = { 1661 .owner = THIS_MODULE, 1662 .open = pktgen_if_open, 1663 .read = seq_read, 1664 .llseek = seq_lseek, 1665 .write = pktgen_if_write, 1666 .release = single_release, 1667 }; 1668 1669 static int pktgen_thread_show(struct seq_file *seq, void *v) 1670 { 1671 struct pktgen_thread *t = seq->private; 1672 struct pktgen_dev *pkt_dev; 1673 1674 BUG_ON(!t); 1675 1676 seq_printf(seq, "Name: %s max_before_softirq: %d\n", 1677 t->tsk->comm, t->max_before_softirq); 1678 1679 seq_printf(seq, "Running: "); 1680 1681 if_lock(t); 1682 list_for_each_entry(pkt_dev, &t->if_list, list) 1683 if (pkt_dev->running) 1684 seq_printf(seq, "%s ", pkt_dev->odev->name); 1685 1686 seq_printf(seq, "\nStopped: "); 1687 1688 list_for_each_entry(pkt_dev, &t->if_list, list) 1689 if (!pkt_dev->running) 1690 seq_printf(seq, "%s ", pkt_dev->odev->name); 1691 1692 if (t->result[0]) 1693 seq_printf(seq, "\nResult: %s\n", t->result); 1694 else 1695 seq_printf(seq, "\nResult: NA\n"); 1696 1697 if_unlock(t); 1698 1699 return 0; 1700 } 1701 1702 static ssize_t pktgen_thread_write(struct file *file, 1703 const char __user * user_buffer, 1704 size_t count, loff_t * offset) 1705 { 1706 struct seq_file *seq = (struct seq_file *)file->private_data; 1707 struct pktgen_thread *t = seq->private; 1708 int i = 0, max, len, ret; 1709 char name[40]; 1710 char *pg_result; 1711 unsigned long value = 0; 1712 1713 if (count < 1) { 1714 // sprintf(pg_result, "Wrong command format"); 1715 return -EINVAL; 1716 } 1717 1718 max = count - i; 1719 len = count_trail_chars(&user_buffer[i], max); 1720 if (len < 0) 1721 return len; 1722 1723 i += len; 1724 1725 /* Read variable name */ 1726 1727 len = strn_len(&user_buffer[i], sizeof(name) - 1); 1728 if (len < 0) 1729 return len; 1730 1731 memset(name, 0, sizeof(name)); 1732 if (copy_from_user(name, &user_buffer[i], len)) 1733 return -EFAULT; 1734 i += len; 1735 1736 max = count - i; 1737 len = count_trail_chars(&user_buffer[i], max); 1738 if (len < 0) 1739 return len; 1740 1741 i += len; 1742 1743 if (debug) 1744 printk("pktgen: t=%s, count=%lu\n", name, (unsigned long)count); 1745 1746 if (!t) { 1747 printk("pktgen: ERROR: No thread\n"); 1748 ret = -EINVAL; 1749 goto out; 1750 } 1751 1752 pg_result = &(t->result[0]); 1753 1754 if (!strcmp(name, "add_device")) { 1755 char f[32]; 1756 memset(f, 0, 32); 1757 len = strn_len(&user_buffer[i], sizeof(f) - 1); 1758 if (len < 0) { 1759 ret = len; 1760 goto out; 1761 } 1762 if (copy_from_user(f, &user_buffer[i], len)) 1763 return -EFAULT; 1764 i += len; 1765 mutex_lock(&pktgen_thread_lock); 1766 pktgen_add_device(t, f); 1767 mutex_unlock(&pktgen_thread_lock); 1768 ret = count; 1769 sprintf(pg_result, "OK: add_device=%s", f); 1770 goto out; 1771 } 1772 1773 if (!strcmp(name, "rem_device_all")) { 1774 mutex_lock(&pktgen_thread_lock); 1775 t->control |= T_REMDEVALL; 1776 mutex_unlock(&pktgen_thread_lock); 1777 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */ 1778 ret = count; 1779 sprintf(pg_result, "OK: rem_device_all"); 1780 goto out; 1781 } 1782 1783 if (!strcmp(name, "max_before_softirq")) { 1784 len = num_arg(&user_buffer[i], 10, &value); 1785 mutex_lock(&pktgen_thread_lock); 1786 t->max_before_softirq = value; 1787 mutex_unlock(&pktgen_thread_lock); 1788 ret = count; 1789 sprintf(pg_result, "OK: max_before_softirq=%lu", value); 1790 goto out; 1791 } 1792 1793 ret = -EINVAL; 1794 out: 1795 return ret; 1796 } 1797 1798 static int pktgen_thread_open(struct inode *inode, struct file *file) 1799 { 1800 return single_open(file, pktgen_thread_show, PDE(inode)->data); 1801 } 1802 1803 static const struct file_operations pktgen_thread_fops = { 1804 .owner = THIS_MODULE, 1805 .open = pktgen_thread_open, 1806 .read = seq_read, 1807 .llseek = seq_lseek, 1808 .write = pktgen_thread_write, 1809 .release = single_release, 1810 }; 1811 1812 /* Think find or remove for NN */ 1813 static struct pktgen_dev *__pktgen_NN_threads(const char *ifname, int remove) 1814 { 1815 struct pktgen_thread *t; 1816 struct pktgen_dev *pkt_dev = NULL; 1817 1818 list_for_each_entry(t, &pktgen_threads, th_list) { 1819 pkt_dev = pktgen_find_dev(t, ifname); 1820 if (pkt_dev) { 1821 if (remove) { 1822 if_lock(t); 1823 pkt_dev->removal_mark = 1; 1824 t->control |= T_REMDEV; 1825 if_unlock(t); 1826 } 1827 break; 1828 } 1829 } 1830 return pkt_dev; 1831 } 1832 1833 /* 1834 * mark a device for removal 1835 */ 1836 static void pktgen_mark_device(const char *ifname) 1837 { 1838 struct pktgen_dev *pkt_dev = NULL; 1839 const int max_tries = 10, msec_per_try = 125; 1840 int i = 0; 1841 1842 mutex_lock(&pktgen_thread_lock); 1843 pr_debug("pktgen: pktgen_mark_device marking %s for removal\n", ifname); 1844 1845 while (1) { 1846 1847 pkt_dev = __pktgen_NN_threads(ifname, REMOVE); 1848 if (pkt_dev == NULL) 1849 break; /* success */ 1850 1851 mutex_unlock(&pktgen_thread_lock); 1852 pr_debug("pktgen: pktgen_mark_device waiting for %s " 1853 "to disappear....\n", ifname); 1854 schedule_timeout_interruptible(msecs_to_jiffies(msec_per_try)); 1855 mutex_lock(&pktgen_thread_lock); 1856 1857 if (++i >= max_tries) { 1858 printk("pktgen_mark_device: timed out after waiting " 1859 "%d msec for device %s to be removed\n", 1860 msec_per_try * i, ifname); 1861 break; 1862 } 1863 1864 } 1865 1866 mutex_unlock(&pktgen_thread_lock); 1867 } 1868 1869 static void pktgen_change_name(struct net_device *dev) 1870 { 1871 struct pktgen_thread *t; 1872 1873 list_for_each_entry(t, &pktgen_threads, th_list) { 1874 struct pktgen_dev *pkt_dev; 1875 1876 list_for_each_entry(pkt_dev, &t->if_list, list) { 1877 if (pkt_dev->odev != dev) 1878 continue; 1879 1880 remove_proc_entry(pkt_dev->entry->name, pg_proc_dir); 1881 1882 pkt_dev->entry = create_proc_entry(dev->name, 0600, 1883 pg_proc_dir); 1884 if (!pkt_dev->entry) 1885 printk(KERN_ERR "pktgen: can't move proc " 1886 " entry for '%s'\n", dev->name); 1887 break; 1888 } 1889 } 1890 } 1891 1892 static int pktgen_device_event(struct notifier_block *unused, 1893 unsigned long event, void *ptr) 1894 { 1895 struct net_device *dev = ptr; 1896 1897 /* It is OK that we do not hold the group lock right now, 1898 * as we run under the RTNL lock. 1899 */ 1900 1901 switch (event) { 1902 case NETDEV_CHANGENAME: 1903 pktgen_change_name(dev); 1904 break; 1905 1906 case NETDEV_UNREGISTER: 1907 pktgen_mark_device(dev->name); 1908 break; 1909 } 1910 1911 return NOTIFY_DONE; 1912 } 1913 1914 /* Associate pktgen_dev with a device. */ 1915 1916 static int pktgen_setup_dev(struct pktgen_dev *pkt_dev, const char *ifname) 1917 { 1918 struct net_device *odev; 1919 int err; 1920 1921 /* Clean old setups */ 1922 if (pkt_dev->odev) { 1923 dev_put(pkt_dev->odev); 1924 pkt_dev->odev = NULL; 1925 } 1926 1927 odev = dev_get_by_name(ifname); 1928 if (!odev) { 1929 printk("pktgen: no such netdevice: \"%s\"\n", ifname); 1930 return -ENODEV; 1931 } 1932 1933 if (odev->type != ARPHRD_ETHER) { 1934 printk("pktgen: not an ethernet device: \"%s\"\n", ifname); 1935 err = -EINVAL; 1936 } else if (!netif_running(odev)) { 1937 printk("pktgen: device is down: \"%s\"\n", ifname); 1938 err = -ENETDOWN; 1939 } else { 1940 pkt_dev->odev = odev; 1941 return 0; 1942 } 1943 1944 dev_put(odev); 1945 return err; 1946 } 1947 1948 /* Read pkt_dev from the interface and set up internal pktgen_dev 1949 * structure to have the right information to create/send packets 1950 */ 1951 static void pktgen_setup_inject(struct pktgen_dev *pkt_dev) 1952 { 1953 if (!pkt_dev->odev) { 1954 printk("pktgen: ERROR: pkt_dev->odev == NULL in setup_inject.\n"); 1955 sprintf(pkt_dev->result, 1956 "ERROR: pkt_dev->odev == NULL in setup_inject.\n"); 1957 return; 1958 } 1959 1960 /* Default to the interface's mac if not explicitly set. */ 1961 1962 if (is_zero_ether_addr(pkt_dev->src_mac)) 1963 memcpy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr, ETH_ALEN); 1964 1965 /* Set up Dest MAC */ 1966 memcpy(&(pkt_dev->hh[0]), pkt_dev->dst_mac, ETH_ALEN); 1967 1968 /* Set up pkt size */ 1969 pkt_dev->cur_pkt_size = pkt_dev->min_pkt_size; 1970 1971 if (pkt_dev->flags & F_IPV6) { 1972 /* 1973 * Skip this automatic address setting until locks or functions 1974 * gets exported 1975 */ 1976 1977 #ifdef NOTNOW 1978 int i, set = 0, err = 1; 1979 struct inet6_dev *idev; 1980 1981 for (i = 0; i < IN6_ADDR_HSIZE; i++) 1982 if (pkt_dev->cur_in6_saddr.s6_addr[i]) { 1983 set = 1; 1984 break; 1985 } 1986 1987 if (!set) { 1988 1989 /* 1990 * Use linklevel address if unconfigured. 1991 * 1992 * use ipv6_get_lladdr if/when it's get exported 1993 */ 1994 1995 rcu_read_lock(); 1996 if ((idev = __in6_dev_get(pkt_dev->odev)) != NULL) { 1997 struct inet6_ifaddr *ifp; 1998 1999 read_lock_bh(&idev->lock); 2000 for (ifp = idev->addr_list; ifp; 2001 ifp = ifp->if_next) { 2002 if (ifp->scope == IFA_LINK 2003 && !(ifp-> 2004 flags & IFA_F_TENTATIVE)) { 2005 ipv6_addr_copy(&pkt_dev-> 2006 cur_in6_saddr, 2007 &ifp->addr); 2008 err = 0; 2009 break; 2010 } 2011 } 2012 read_unlock_bh(&idev->lock); 2013 } 2014 rcu_read_unlock(); 2015 if (err) 2016 printk("pktgen: ERROR: IPv6 link address not availble.\n"); 2017 } 2018 #endif 2019 } else { 2020 pkt_dev->saddr_min = 0; 2021 pkt_dev->saddr_max = 0; 2022 if (strlen(pkt_dev->src_min) == 0) { 2023 2024 struct in_device *in_dev; 2025 2026 rcu_read_lock(); 2027 in_dev = __in_dev_get_rcu(pkt_dev->odev); 2028 if (in_dev) { 2029 if (in_dev->ifa_list) { 2030 pkt_dev->saddr_min = 2031 in_dev->ifa_list->ifa_address; 2032 pkt_dev->saddr_max = pkt_dev->saddr_min; 2033 } 2034 } 2035 rcu_read_unlock(); 2036 } else { 2037 pkt_dev->saddr_min = in_aton(pkt_dev->src_min); 2038 pkt_dev->saddr_max = in_aton(pkt_dev->src_max); 2039 } 2040 2041 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min); 2042 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max); 2043 } 2044 /* Initialize current values. */ 2045 pkt_dev->cur_dst_mac_offset = 0; 2046 pkt_dev->cur_src_mac_offset = 0; 2047 pkt_dev->cur_saddr = pkt_dev->saddr_min; 2048 pkt_dev->cur_daddr = pkt_dev->daddr_min; 2049 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min; 2050 pkt_dev->cur_udp_src = pkt_dev->udp_src_min; 2051 pkt_dev->nflows = 0; 2052 } 2053 2054 static void spin(struct pktgen_dev *pkt_dev, __u64 spin_until_us) 2055 { 2056 __u64 start; 2057 __u64 now; 2058 2059 start = now = getCurUs(); 2060 printk(KERN_INFO "sleeping for %d\n", (int)(spin_until_us - now)); 2061 while (now < spin_until_us) { 2062 /* TODO: optimize sleeping behavior */ 2063 if (spin_until_us - now > jiffies_to_usecs(1) + 1) 2064 schedule_timeout_interruptible(1); 2065 else if (spin_until_us - now > 100) { 2066 do_softirq(); 2067 if (!pkt_dev->running) 2068 return; 2069 if (need_resched()) 2070 schedule(); 2071 } 2072 2073 now = getCurUs(); 2074 } 2075 2076 pkt_dev->idle_acc += now - start; 2077 } 2078 2079 /* Increment/randomize headers according to flags and current values 2080 * for IP src/dest, UDP src/dst port, MAC-Addr src/dst 2081 */ 2082 static void mod_cur_headers(struct pktgen_dev *pkt_dev) 2083 { 2084 __u32 imn; 2085 __u32 imx; 2086 int flow = 0; 2087 2088 if (pkt_dev->cflows) { 2089 flow = random32() % pkt_dev->cflows; 2090 2091 if (pkt_dev->flows[flow].count > pkt_dev->lflow) 2092 pkt_dev->flows[flow].count = 0; 2093 } 2094 2095 /* Deal with source MAC */ 2096 if (pkt_dev->src_mac_count > 1) { 2097 __u32 mc; 2098 __u32 tmp; 2099 2100 if (pkt_dev->flags & F_MACSRC_RND) 2101 mc = random32() % pkt_dev->src_mac_count; 2102 else { 2103 mc = pkt_dev->cur_src_mac_offset++; 2104 if (pkt_dev->cur_src_mac_offset > 2105 pkt_dev->src_mac_count) 2106 pkt_dev->cur_src_mac_offset = 0; 2107 } 2108 2109 tmp = pkt_dev->src_mac[5] + (mc & 0xFF); 2110 pkt_dev->hh[11] = tmp; 2111 tmp = (pkt_dev->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8)); 2112 pkt_dev->hh[10] = tmp; 2113 tmp = (pkt_dev->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8)); 2114 pkt_dev->hh[9] = tmp; 2115 tmp = (pkt_dev->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8)); 2116 pkt_dev->hh[8] = tmp; 2117 tmp = (pkt_dev->src_mac[1] + (tmp >> 8)); 2118 pkt_dev->hh[7] = tmp; 2119 } 2120 2121 /* Deal with Destination MAC */ 2122 if (pkt_dev->dst_mac_count > 1) { 2123 __u32 mc; 2124 __u32 tmp; 2125 2126 if (pkt_dev->flags & F_MACDST_RND) 2127 mc = random32() % pkt_dev->dst_mac_count; 2128 2129 else { 2130 mc = pkt_dev->cur_dst_mac_offset++; 2131 if (pkt_dev->cur_dst_mac_offset > 2132 pkt_dev->dst_mac_count) { 2133 pkt_dev->cur_dst_mac_offset = 0; 2134 } 2135 } 2136 2137 tmp = pkt_dev->dst_mac[5] + (mc & 0xFF); 2138 pkt_dev->hh[5] = tmp; 2139 tmp = (pkt_dev->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8)); 2140 pkt_dev->hh[4] = tmp; 2141 tmp = (pkt_dev->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8)); 2142 pkt_dev->hh[3] = tmp; 2143 tmp = (pkt_dev->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8)); 2144 pkt_dev->hh[2] = tmp; 2145 tmp = (pkt_dev->dst_mac[1] + (tmp >> 8)); 2146 pkt_dev->hh[1] = tmp; 2147 } 2148 2149 if (pkt_dev->flags & F_MPLS_RND) { 2150 unsigned i; 2151 for (i = 0; i < pkt_dev->nr_labels; i++) 2152 if (pkt_dev->labels[i] & MPLS_STACK_BOTTOM) 2153 pkt_dev->labels[i] = MPLS_STACK_BOTTOM | 2154 ((__force __be32)random32() & 2155 htonl(0x000fffff)); 2156 } 2157 2158 if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) { 2159 pkt_dev->vlan_id = random32() & (4096-1); 2160 } 2161 2162 if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) { 2163 pkt_dev->svlan_id = random32() & (4096 - 1); 2164 } 2165 2166 if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) { 2167 if (pkt_dev->flags & F_UDPSRC_RND) 2168 pkt_dev->cur_udp_src = random32() % 2169 (pkt_dev->udp_src_max - pkt_dev->udp_src_min) 2170 + pkt_dev->udp_src_min; 2171 2172 else { 2173 pkt_dev->cur_udp_src++; 2174 if (pkt_dev->cur_udp_src >= pkt_dev->udp_src_max) 2175 pkt_dev->cur_udp_src = pkt_dev->udp_src_min; 2176 } 2177 } 2178 2179 if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) { 2180 if (pkt_dev->flags & F_UDPDST_RND) { 2181 pkt_dev->cur_udp_dst = random32() % 2182 (pkt_dev->udp_dst_max - pkt_dev->udp_dst_min) 2183 + pkt_dev->udp_dst_min; 2184 } else { 2185 pkt_dev->cur_udp_dst++; 2186 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max) 2187 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min; 2188 } 2189 } 2190 2191 if (!(pkt_dev->flags & F_IPV6)) { 2192 2193 if ((imn = ntohl(pkt_dev->saddr_min)) < (imx = 2194 ntohl(pkt_dev-> 2195 saddr_max))) { 2196 __u32 t; 2197 if (pkt_dev->flags & F_IPSRC_RND) 2198 t = random32() % (imx - imn) + imn; 2199 else { 2200 t = ntohl(pkt_dev->cur_saddr); 2201 t++; 2202 if (t > imx) { 2203 t = imn; 2204 } 2205 } 2206 pkt_dev->cur_saddr = htonl(t); 2207 } 2208 2209 if (pkt_dev->cflows && pkt_dev->flows[flow].count != 0) { 2210 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr; 2211 } else { 2212 imn = ntohl(pkt_dev->daddr_min); 2213 imx = ntohl(pkt_dev->daddr_max); 2214 if (imn < imx) { 2215 __u32 t; 2216 __be32 s; 2217 if (pkt_dev->flags & F_IPDST_RND) { 2218 2219 t = random32() % (imx - imn) + imn; 2220 s = htonl(t); 2221 2222 while (LOOPBACK(s) || MULTICAST(s) 2223 || BADCLASS(s) || ZERONET(s) 2224 || LOCAL_MCAST(s)) { 2225 t = random32() % (imx - imn) + imn; 2226 s = htonl(t); 2227 } 2228 pkt_dev->cur_daddr = s; 2229 } else { 2230 t = ntohl(pkt_dev->cur_daddr); 2231 t++; 2232 if (t > imx) { 2233 t = imn; 2234 } 2235 pkt_dev->cur_daddr = htonl(t); 2236 } 2237 } 2238 if (pkt_dev->cflows) { 2239 pkt_dev->flows[flow].cur_daddr = 2240 pkt_dev->cur_daddr; 2241 pkt_dev->nflows++; 2242 } 2243 } 2244 } else { /* IPV6 * */ 2245 2246 if (pkt_dev->min_in6_daddr.s6_addr32[0] == 0 && 2247 pkt_dev->min_in6_daddr.s6_addr32[1] == 0 && 2248 pkt_dev->min_in6_daddr.s6_addr32[2] == 0 && 2249 pkt_dev->min_in6_daddr.s6_addr32[3] == 0) ; 2250 else { 2251 int i; 2252 2253 /* Only random destinations yet */ 2254 2255 for (i = 0; i < 4; i++) { 2256 pkt_dev->cur_in6_daddr.s6_addr32[i] = 2257 (((__force __be32)random32() | 2258 pkt_dev->min_in6_daddr.s6_addr32[i]) & 2259 pkt_dev->max_in6_daddr.s6_addr32[i]); 2260 } 2261 } 2262 } 2263 2264 if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) { 2265 __u32 t; 2266 if (pkt_dev->flags & F_TXSIZE_RND) { 2267 t = random32() % 2268 (pkt_dev->max_pkt_size - pkt_dev->min_pkt_size) 2269 + pkt_dev->min_pkt_size; 2270 } else { 2271 t = pkt_dev->cur_pkt_size + 1; 2272 if (t > pkt_dev->max_pkt_size) 2273 t = pkt_dev->min_pkt_size; 2274 } 2275 pkt_dev->cur_pkt_size = t; 2276 } 2277 2278 pkt_dev->flows[flow].count++; 2279 } 2280 2281 static void mpls_push(__be32 *mpls, struct pktgen_dev *pkt_dev) 2282 { 2283 unsigned i; 2284 for (i = 0; i < pkt_dev->nr_labels; i++) { 2285 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM; 2286 } 2287 mpls--; 2288 *mpls |= MPLS_STACK_BOTTOM; 2289 } 2290 2291 static inline __be16 build_tci(unsigned int id, unsigned int cfi, 2292 unsigned int prio) 2293 { 2294 return htons(id | (cfi << 12) | (prio << 13)); 2295 } 2296 2297 static struct sk_buff *fill_packet_ipv4(struct net_device *odev, 2298 struct pktgen_dev *pkt_dev) 2299 { 2300 struct sk_buff *skb = NULL; 2301 __u8 *eth; 2302 struct udphdr *udph; 2303 int datalen, iplen; 2304 struct iphdr *iph; 2305 struct pktgen_hdr *pgh = NULL; 2306 __be16 protocol = htons(ETH_P_IP); 2307 __be32 *mpls; 2308 __be16 *vlan_tci = NULL; /* Encapsulates priority and VLAN ID */ 2309 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */ 2310 __be16 *svlan_tci = NULL; /* Encapsulates priority and SVLAN ID */ 2311 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */ 2312 2313 2314 if (pkt_dev->nr_labels) 2315 protocol = htons(ETH_P_MPLS_UC); 2316 2317 if (pkt_dev->vlan_id != 0xffff) 2318 protocol = htons(ETH_P_8021Q); 2319 2320 /* Update any of the values, used when we're incrementing various 2321 * fields. 2322 */ 2323 mod_cur_headers(pkt_dev); 2324 2325 datalen = (odev->hard_header_len + 16) & ~0xf; 2326 skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + datalen + 2327 pkt_dev->nr_labels*sizeof(u32) + 2328 VLAN_TAG_SIZE(pkt_dev) + SVLAN_TAG_SIZE(pkt_dev), 2329 GFP_ATOMIC); 2330 if (!skb) { 2331 sprintf(pkt_dev->result, "No memory"); 2332 return NULL; 2333 } 2334 2335 skb_reserve(skb, datalen); 2336 2337 /* Reserve for ethernet and IP header */ 2338 eth = (__u8 *) skb_push(skb, 14); 2339 mpls = (__be32 *)skb_put(skb, pkt_dev->nr_labels*sizeof(__u32)); 2340 if (pkt_dev->nr_labels) 2341 mpls_push(mpls, pkt_dev); 2342 2343 if (pkt_dev->vlan_id != 0xffff) { 2344 if (pkt_dev->svlan_id != 0xffff) { 2345 svlan_tci = (__be16 *)skb_put(skb, sizeof(__be16)); 2346 *svlan_tci = build_tci(pkt_dev->svlan_id, 2347 pkt_dev->svlan_cfi, 2348 pkt_dev->svlan_p); 2349 svlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16)); 2350 *svlan_encapsulated_proto = htons(ETH_P_8021Q); 2351 } 2352 vlan_tci = (__be16 *)skb_put(skb, sizeof(__be16)); 2353 *vlan_tci = build_tci(pkt_dev->vlan_id, 2354 pkt_dev->vlan_cfi, 2355 pkt_dev->vlan_p); 2356 vlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16)); 2357 *vlan_encapsulated_proto = htons(ETH_P_IP); 2358 } 2359 2360 skb->network_header = skb->tail; 2361 skb->transport_header = skb->network_header + sizeof(struct iphdr); 2362 skb_put(skb, sizeof(struct iphdr) + sizeof(struct udphdr)); 2363 2364 iph = ip_hdr(skb); 2365 udph = udp_hdr(skb); 2366 2367 memcpy(eth, pkt_dev->hh, 12); 2368 *(__be16 *) & eth[12] = protocol; 2369 2370 /* Eth + IPh + UDPh + mpls */ 2371 datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 - 2372 pkt_dev->nr_labels*sizeof(u32) - VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev); 2373 if (datalen < sizeof(struct pktgen_hdr)) 2374 datalen = sizeof(struct pktgen_hdr); 2375 2376 udph->source = htons(pkt_dev->cur_udp_src); 2377 udph->dest = htons(pkt_dev->cur_udp_dst); 2378 udph->len = htons(datalen + 8); /* DATA + udphdr */ 2379 udph->check = 0; /* No checksum */ 2380 2381 iph->ihl = 5; 2382 iph->version = 4; 2383 iph->ttl = 32; 2384 iph->tos = pkt_dev->tos; 2385 iph->protocol = IPPROTO_UDP; /* UDP */ 2386 iph->saddr = pkt_dev->cur_saddr; 2387 iph->daddr = pkt_dev->cur_daddr; 2388 iph->frag_off = 0; 2389 iplen = 20 + 8 + datalen; 2390 iph->tot_len = htons(iplen); 2391 iph->check = 0; 2392 iph->check = ip_fast_csum((void *)iph, iph->ihl); 2393 skb->protocol = protocol; 2394 skb->mac_header = (skb->network_header - ETH_HLEN - 2395 pkt_dev->nr_labels * sizeof(u32) - 2396 VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev)); 2397 skb->dev = odev; 2398 skb->pkt_type = PACKET_HOST; 2399 2400 if (pkt_dev->nfrags <= 0) 2401 pgh = (struct pktgen_hdr *)skb_put(skb, datalen); 2402 else { 2403 int frags = pkt_dev->nfrags; 2404 int i; 2405 2406 pgh = (struct pktgen_hdr *)(((char *)(udph)) + 8); 2407 2408 if (frags > MAX_SKB_FRAGS) 2409 frags = MAX_SKB_FRAGS; 2410 if (datalen > frags * PAGE_SIZE) { 2411 skb_put(skb, datalen - frags * PAGE_SIZE); 2412 datalen = frags * PAGE_SIZE; 2413 } 2414 2415 i = 0; 2416 while (datalen > 0) { 2417 struct page *page = alloc_pages(GFP_KERNEL, 0); 2418 skb_shinfo(skb)->frags[i].page = page; 2419 skb_shinfo(skb)->frags[i].page_offset = 0; 2420 skb_shinfo(skb)->frags[i].size = 2421 (datalen < PAGE_SIZE ? datalen : PAGE_SIZE); 2422 datalen -= skb_shinfo(skb)->frags[i].size; 2423 skb->len += skb_shinfo(skb)->frags[i].size; 2424 skb->data_len += skb_shinfo(skb)->frags[i].size; 2425 i++; 2426 skb_shinfo(skb)->nr_frags = i; 2427 } 2428 2429 while (i < frags) { 2430 int rem; 2431 2432 if (i == 0) 2433 break; 2434 2435 rem = skb_shinfo(skb)->frags[i - 1].size / 2; 2436 if (rem == 0) 2437 break; 2438 2439 skb_shinfo(skb)->frags[i - 1].size -= rem; 2440 2441 skb_shinfo(skb)->frags[i] = 2442 skb_shinfo(skb)->frags[i - 1]; 2443 get_page(skb_shinfo(skb)->frags[i].page); 2444 skb_shinfo(skb)->frags[i].page = 2445 skb_shinfo(skb)->frags[i - 1].page; 2446 skb_shinfo(skb)->frags[i].page_offset += 2447 skb_shinfo(skb)->frags[i - 1].size; 2448 skb_shinfo(skb)->frags[i].size = rem; 2449 i++; 2450 skb_shinfo(skb)->nr_frags = i; 2451 } 2452 } 2453 2454 /* Stamp the time, and sequence number, convert them to network byte order */ 2455 2456 if (pgh) { 2457 struct timeval timestamp; 2458 2459 pgh->pgh_magic = htonl(PKTGEN_MAGIC); 2460 pgh->seq_num = htonl(pkt_dev->seq_num); 2461 2462 do_gettimeofday(×tamp); 2463 pgh->tv_sec = htonl(timestamp.tv_sec); 2464 pgh->tv_usec = htonl(timestamp.tv_usec); 2465 } 2466 2467 return skb; 2468 } 2469 2470 /* 2471 * scan_ip6, fmt_ip taken from dietlibc-0.21 2472 * Author Felix von Leitner <felix-dietlibc@fefe.de> 2473 * 2474 * Slightly modified for kernel. 2475 * Should be candidate for net/ipv4/utils.c 2476 * --ro 2477 */ 2478 2479 static unsigned int scan_ip6(const char *s, char ip[16]) 2480 { 2481 unsigned int i; 2482 unsigned int len = 0; 2483 unsigned long u; 2484 char suffix[16]; 2485 unsigned int prefixlen = 0; 2486 unsigned int suffixlen = 0; 2487 __be32 tmp; 2488 2489 for (i = 0; i < 16; i++) 2490 ip[i] = 0; 2491 2492 for (;;) { 2493 if (*s == ':') { 2494 len++; 2495 if (s[1] == ':') { /* Found "::", skip to part 2 */ 2496 s += 2; 2497 len++; 2498 break; 2499 } 2500 s++; 2501 } 2502 { 2503 char *tmp; 2504 u = simple_strtoul(s, &tmp, 16); 2505 i = tmp - s; 2506 } 2507 2508 if (!i) 2509 return 0; 2510 if (prefixlen == 12 && s[i] == '.') { 2511 2512 /* the last 4 bytes may be written as IPv4 address */ 2513 2514 tmp = in_aton(s); 2515 memcpy((struct in_addr *)(ip + 12), &tmp, sizeof(tmp)); 2516 return i + len; 2517 } 2518 ip[prefixlen++] = (u >> 8); 2519 ip[prefixlen++] = (u & 255); 2520 s += i; 2521 len += i; 2522 if (prefixlen == 16) 2523 return len; 2524 } 2525 2526 /* part 2, after "::" */ 2527 for (;;) { 2528 if (*s == ':') { 2529 if (suffixlen == 0) 2530 break; 2531 s++; 2532 len++; 2533 } else if (suffixlen != 0) 2534 break; 2535 { 2536 char *tmp; 2537 u = simple_strtol(s, &tmp, 16); 2538 i = tmp - s; 2539 } 2540 if (!i) { 2541 if (*s) 2542 len--; 2543 break; 2544 } 2545 if (suffixlen + prefixlen <= 12 && s[i] == '.') { 2546 tmp = in_aton(s); 2547 memcpy((struct in_addr *)(suffix + suffixlen), &tmp, 2548 sizeof(tmp)); 2549 suffixlen += 4; 2550 len += strlen(s); 2551 break; 2552 } 2553 suffix[suffixlen++] = (u >> 8); 2554 suffix[suffixlen++] = (u & 255); 2555 s += i; 2556 len += i; 2557 if (prefixlen + suffixlen == 16) 2558 break; 2559 } 2560 for (i = 0; i < suffixlen; i++) 2561 ip[16 - suffixlen + i] = suffix[i]; 2562 return len; 2563 } 2564 2565 static char tohex(char hexdigit) 2566 { 2567 return hexdigit > 9 ? hexdigit + 'a' - 10 : hexdigit + '0'; 2568 } 2569 2570 static int fmt_xlong(char *s, unsigned int i) 2571 { 2572 char *bak = s; 2573 *s = tohex((i >> 12) & 0xf); 2574 if (s != bak || *s != '0') 2575 ++s; 2576 *s = tohex((i >> 8) & 0xf); 2577 if (s != bak || *s != '0') 2578 ++s; 2579 *s = tohex((i >> 4) & 0xf); 2580 if (s != bak || *s != '0') 2581 ++s; 2582 *s = tohex(i & 0xf); 2583 return s - bak + 1; 2584 } 2585 2586 static unsigned int fmt_ip6(char *s, const char ip[16]) 2587 { 2588 unsigned int len; 2589 unsigned int i; 2590 unsigned int temp; 2591 unsigned int compressing; 2592 int j; 2593 2594 len = 0; 2595 compressing = 0; 2596 for (j = 0; j < 16; j += 2) { 2597 2598 #ifdef V4MAPPEDPREFIX 2599 if (j == 12 && !memcmp(ip, V4mappedprefix, 12)) { 2600 inet_ntoa_r(*(struct in_addr *)(ip + 12), s); 2601 temp = strlen(s); 2602 return len + temp; 2603 } 2604 #endif 2605 temp = ((unsigned long)(unsigned char)ip[j] << 8) + 2606 (unsigned long)(unsigned char)ip[j + 1]; 2607 if (temp == 0) { 2608 if (!compressing) { 2609 compressing = 1; 2610 if (j == 0) { 2611 *s++ = ':'; 2612 ++len; 2613 } 2614 } 2615 } else { 2616 if (compressing) { 2617 compressing = 0; 2618 *s++ = ':'; 2619 ++len; 2620 } 2621 i = fmt_xlong(s, temp); 2622 len += i; 2623 s += i; 2624 if (j < 14) { 2625 *s++ = ':'; 2626 ++len; 2627 } 2628 } 2629 } 2630 if (compressing) { 2631 *s++ = ':'; 2632 ++len; 2633 } 2634 *s = 0; 2635 return len; 2636 } 2637 2638 static struct sk_buff *fill_packet_ipv6(struct net_device *odev, 2639 struct pktgen_dev *pkt_dev) 2640 { 2641 struct sk_buff *skb = NULL; 2642 __u8 *eth; 2643 struct udphdr *udph; 2644 int datalen; 2645 struct ipv6hdr *iph; 2646 struct pktgen_hdr *pgh = NULL; 2647 __be16 protocol = htons(ETH_P_IPV6); 2648 __be32 *mpls; 2649 __be16 *vlan_tci = NULL; /* Encapsulates priority and VLAN ID */ 2650 __be16 *vlan_encapsulated_proto = NULL; /* packet type ID field (or len) for VLAN tag */ 2651 __be16 *svlan_tci = NULL; /* Encapsulates priority and SVLAN ID */ 2652 __be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */ 2653 2654 if (pkt_dev->nr_labels) 2655 protocol = htons(ETH_P_MPLS_UC); 2656 2657 if (pkt_dev->vlan_id != 0xffff) 2658 protocol = htons(ETH_P_8021Q); 2659 2660 /* Update any of the values, used when we're incrementing various 2661 * fields. 2662 */ 2663 mod_cur_headers(pkt_dev); 2664 2665 skb = alloc_skb(pkt_dev->cur_pkt_size + 64 + 16 + 2666 pkt_dev->nr_labels*sizeof(u32) + 2667 VLAN_TAG_SIZE(pkt_dev) + SVLAN_TAG_SIZE(pkt_dev), 2668 GFP_ATOMIC); 2669 if (!skb) { 2670 sprintf(pkt_dev->result, "No memory"); 2671 return NULL; 2672 } 2673 2674 skb_reserve(skb, 16); 2675 2676 /* Reserve for ethernet and IP header */ 2677 eth = (__u8 *) skb_push(skb, 14); 2678 mpls = (__be32 *)skb_put(skb, pkt_dev->nr_labels*sizeof(__u32)); 2679 if (pkt_dev->nr_labels) 2680 mpls_push(mpls, pkt_dev); 2681 2682 if (pkt_dev->vlan_id != 0xffff) { 2683 if (pkt_dev->svlan_id != 0xffff) { 2684 svlan_tci = (__be16 *)skb_put(skb, sizeof(__be16)); 2685 *svlan_tci = build_tci(pkt_dev->svlan_id, 2686 pkt_dev->svlan_cfi, 2687 pkt_dev->svlan_p); 2688 svlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16)); 2689 *svlan_encapsulated_proto = htons(ETH_P_8021Q); 2690 } 2691 vlan_tci = (__be16 *)skb_put(skb, sizeof(__be16)); 2692 *vlan_tci = build_tci(pkt_dev->vlan_id, 2693 pkt_dev->vlan_cfi, 2694 pkt_dev->vlan_p); 2695 vlan_encapsulated_proto = (__be16 *)skb_put(skb, sizeof(__be16)); 2696 *vlan_encapsulated_proto = htons(ETH_P_IPV6); 2697 } 2698 2699 skb->network_header = skb->tail; 2700 skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); 2701 skb_put(skb, sizeof(struct ipv6hdr) + sizeof(struct udphdr)); 2702 2703 iph = ipv6_hdr(skb); 2704 udph = udp_hdr(skb); 2705 2706 memcpy(eth, pkt_dev->hh, 12); 2707 *(__be16 *) & eth[12] = protocol; 2708 2709 /* Eth + IPh + UDPh + mpls */ 2710 datalen = pkt_dev->cur_pkt_size - 14 - 2711 sizeof(struct ipv6hdr) - sizeof(struct udphdr) - 2712 pkt_dev->nr_labels*sizeof(u32) - VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev); 2713 2714 if (datalen < sizeof(struct pktgen_hdr)) { 2715 datalen = sizeof(struct pktgen_hdr); 2716 if (net_ratelimit()) 2717 printk(KERN_INFO "pktgen: increased datalen to %d\n", 2718 datalen); 2719 } 2720 2721 udph->source = htons(pkt_dev->cur_udp_src); 2722 udph->dest = htons(pkt_dev->cur_udp_dst); 2723 udph->len = htons(datalen + sizeof(struct udphdr)); 2724 udph->check = 0; /* No checksum */ 2725 2726 *(__be32 *) iph = htonl(0x60000000); /* Version + flow */ 2727 2728 if (pkt_dev->traffic_class) { 2729 /* Version + traffic class + flow (0) */ 2730 *(__be32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20)); 2731 } 2732 2733 iph->hop_limit = 32; 2734 2735 iph->payload_len = htons(sizeof(struct udphdr) + datalen); 2736 iph->nexthdr = IPPROTO_UDP; 2737 2738 ipv6_addr_copy(&iph->daddr, &pkt_dev->cur_in6_daddr); 2739 ipv6_addr_copy(&iph->saddr, &pkt_dev->cur_in6_saddr); 2740 2741 skb->mac_header = (skb->network_header - ETH_HLEN - 2742 pkt_dev->nr_labels * sizeof(u32) - 2743 VLAN_TAG_SIZE(pkt_dev) - SVLAN_TAG_SIZE(pkt_dev)); 2744 skb->protocol = protocol; 2745 skb->dev = odev; 2746 skb->pkt_type = PACKET_HOST; 2747 2748 if (pkt_dev->nfrags <= 0) 2749 pgh = (struct pktgen_hdr *)skb_put(skb, datalen); 2750 else { 2751 int frags = pkt_dev->nfrags; 2752 int i; 2753 2754 pgh = (struct pktgen_hdr *)(((char *)(udph)) + 8); 2755 2756 if (frags > MAX_SKB_FRAGS) 2757 frags = MAX_SKB_FRAGS; 2758 if (datalen > frags * PAGE_SIZE) { 2759 skb_put(skb, datalen - frags * PAGE_SIZE); 2760 datalen = frags * PAGE_SIZE; 2761 } 2762 2763 i = 0; 2764 while (datalen > 0) { 2765 struct page *page = alloc_pages(GFP_KERNEL, 0); 2766 skb_shinfo(skb)->frags[i].page = page; 2767 skb_shinfo(skb)->frags[i].page_offset = 0; 2768 skb_shinfo(skb)->frags[i].size = 2769 (datalen < PAGE_SIZE ? datalen : PAGE_SIZE); 2770 datalen -= skb_shinfo(skb)->frags[i].size; 2771 skb->len += skb_shinfo(skb)->frags[i].size; 2772 skb->data_len += skb_shinfo(skb)->frags[i].size; 2773 i++; 2774 skb_shinfo(skb)->nr_frags = i; 2775 } 2776 2777 while (i < frags) { 2778 int rem; 2779 2780 if (i == 0) 2781 break; 2782 2783 rem = skb_shinfo(skb)->frags[i - 1].size / 2; 2784 if (rem == 0) 2785 break; 2786 2787 skb_shinfo(skb)->frags[i - 1].size -= rem; 2788 2789 skb_shinfo(skb)->frags[i] = 2790 skb_shinfo(skb)->frags[i - 1]; 2791 get_page(skb_shinfo(skb)->frags[i].page); 2792 skb_shinfo(skb)->frags[i].page = 2793 skb_shinfo(skb)->frags[i - 1].page; 2794 skb_shinfo(skb)->frags[i].page_offset += 2795 skb_shinfo(skb)->frags[i - 1].size; 2796 skb_shinfo(skb)->frags[i].size = rem; 2797 i++; 2798 skb_shinfo(skb)->nr_frags = i; 2799 } 2800 } 2801 2802 /* Stamp the time, and sequence number, convert them to network byte order */ 2803 /* should we update cloned packets too ? */ 2804 if (pgh) { 2805 struct timeval timestamp; 2806 2807 pgh->pgh_magic = htonl(PKTGEN_MAGIC); 2808 pgh->seq_num = htonl(pkt_dev->seq_num); 2809 2810 do_gettimeofday(×tamp); 2811 pgh->tv_sec = htonl(timestamp.tv_sec); 2812 pgh->tv_usec = htonl(timestamp.tv_usec); 2813 } 2814 /* pkt_dev->seq_num++; FF: you really mean this? */ 2815 2816 return skb; 2817 } 2818 2819 static inline struct sk_buff *fill_packet(struct net_device *odev, 2820 struct pktgen_dev *pkt_dev) 2821 { 2822 if (pkt_dev->flags & F_IPV6) 2823 return fill_packet_ipv6(odev, pkt_dev); 2824 else 2825 return fill_packet_ipv4(odev, pkt_dev); 2826 } 2827 2828 static void pktgen_clear_counters(struct pktgen_dev *pkt_dev) 2829 { 2830 pkt_dev->seq_num = 1; 2831 pkt_dev->idle_acc = 0; 2832 pkt_dev->sofar = 0; 2833 pkt_dev->tx_bytes = 0; 2834 pkt_dev->errors = 0; 2835 } 2836 2837 /* Set up structure for sending pkts, clear counters */ 2838 2839 static void pktgen_run(struct pktgen_thread *t) 2840 { 2841 struct pktgen_dev *pkt_dev; 2842 int started = 0; 2843 2844 pr_debug("pktgen: entering pktgen_run. %p\n", t); 2845 2846 if_lock(t); 2847 list_for_each_entry(pkt_dev, &t->if_list, list) { 2848 2849 /* 2850 * setup odev and create initial packet. 2851 */ 2852 pktgen_setup_inject(pkt_dev); 2853 2854 if (pkt_dev->odev) { 2855 pktgen_clear_counters(pkt_dev); 2856 pkt_dev->running = 1; /* Cranke yeself! */ 2857 pkt_dev->skb = NULL; 2858 pkt_dev->started_at = getCurUs(); 2859 pkt_dev->next_tx_us = getCurUs(); /* Transmit immediately */ 2860 pkt_dev->next_tx_ns = 0; 2861 2862 strcpy(pkt_dev->result, "Starting"); 2863 started++; 2864 } else 2865 strcpy(pkt_dev->result, "Error starting"); 2866 } 2867 if_unlock(t); 2868 if (started) 2869 t->control &= ~(T_STOP); 2870 } 2871 2872 static void pktgen_stop_all_threads_ifs(void) 2873 { 2874 struct pktgen_thread *t; 2875 2876 pr_debug("pktgen: entering pktgen_stop_all_threads_ifs.\n"); 2877 2878 mutex_lock(&pktgen_thread_lock); 2879 2880 list_for_each_entry(t, &pktgen_threads, th_list) 2881 t->control |= T_STOP; 2882 2883 mutex_unlock(&pktgen_thread_lock); 2884 } 2885 2886 static int thread_is_running(struct pktgen_thread *t) 2887 { 2888 struct pktgen_dev *pkt_dev; 2889 int res = 0; 2890 2891 list_for_each_entry(pkt_dev, &t->if_list, list) 2892 if (pkt_dev->running) { 2893 res = 1; 2894 break; 2895 } 2896 return res; 2897 } 2898 2899 static int pktgen_wait_thread_run(struct pktgen_thread *t) 2900 { 2901 if_lock(t); 2902 2903 while (thread_is_running(t)) { 2904 2905 if_unlock(t); 2906 2907 msleep_interruptible(100); 2908 2909 if (signal_pending(current)) 2910 goto signal; 2911 if_lock(t); 2912 } 2913 if_unlock(t); 2914 return 1; 2915 signal: 2916 return 0; 2917 } 2918 2919 static int pktgen_wait_all_threads_run(void) 2920 { 2921 struct pktgen_thread *t; 2922 int sig = 1; 2923 2924 mutex_lock(&pktgen_thread_lock); 2925 2926 list_for_each_entry(t, &pktgen_threads, th_list) { 2927 sig = pktgen_wait_thread_run(t); 2928 if (sig == 0) 2929 break; 2930 } 2931 2932 if (sig == 0) 2933 list_for_each_entry(t, &pktgen_threads, th_list) 2934 t->control |= (T_STOP); 2935 2936 mutex_unlock(&pktgen_thread_lock); 2937 return sig; 2938 } 2939 2940 static void pktgen_run_all_threads(void) 2941 { 2942 struct pktgen_thread *t; 2943 2944 pr_debug("pktgen: entering pktgen_run_all_threads.\n"); 2945 2946 mutex_lock(&pktgen_thread_lock); 2947 2948 list_for_each_entry(t, &pktgen_threads, th_list) 2949 t->control |= (T_RUN); 2950 2951 mutex_unlock(&pktgen_thread_lock); 2952 2953 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */ 2954 2955 pktgen_wait_all_threads_run(); 2956 } 2957 2958 static void show_results(struct pktgen_dev *pkt_dev, int nr_frags) 2959 { 2960 __u64 total_us, bps, mbps, pps, idle; 2961 char *p = pkt_dev->result; 2962 2963 total_us = pkt_dev->stopped_at - pkt_dev->started_at; 2964 2965 idle = pkt_dev->idle_acc; 2966 2967 p += sprintf(p, "OK: %llu(c%llu+d%llu) usec, %llu (%dbyte,%dfrags)\n", 2968 (unsigned long long)total_us, 2969 (unsigned long long)(total_us - idle), 2970 (unsigned long long)idle, 2971 (unsigned long long)pkt_dev->sofar, 2972 pkt_dev->cur_pkt_size, nr_frags); 2973 2974 pps = pkt_dev->sofar * USEC_PER_SEC; 2975 2976 while ((total_us >> 32) != 0) { 2977 pps >>= 1; 2978 total_us >>= 1; 2979 } 2980 2981 do_div(pps, total_us); 2982 2983 bps = pps * 8 * pkt_dev->cur_pkt_size; 2984 2985 mbps = bps; 2986 do_div(mbps, 1000000); 2987 p += sprintf(p, " %llupps %lluMb/sec (%llubps) errors: %llu", 2988 (unsigned long long)pps, 2989 (unsigned long long)mbps, 2990 (unsigned long long)bps, 2991 (unsigned long long)pkt_dev->errors); 2992 } 2993 2994 /* Set stopped-at timer, remove from running list, do counters & statistics */ 2995 2996 static int pktgen_stop_device(struct pktgen_dev *pkt_dev) 2997 { 2998 int nr_frags = pkt_dev->skb ? skb_shinfo(pkt_dev->skb)->nr_frags : -1; 2999 3000 if (!pkt_dev->running) { 3001 printk("pktgen: interface: %s is already stopped\n", 3002 pkt_dev->odev->name); 3003 return -EINVAL; 3004 } 3005 3006 pkt_dev->stopped_at = getCurUs(); 3007 pkt_dev->running = 0; 3008 3009 show_results(pkt_dev, nr_frags); 3010 3011 return 0; 3012 } 3013 3014 static struct pktgen_dev *next_to_run(struct pktgen_thread *t) 3015 { 3016 struct pktgen_dev *pkt_dev, *best = NULL; 3017 3018 if_lock(t); 3019 3020 list_for_each_entry(pkt_dev, &t->if_list, list) { 3021 if (!pkt_dev->running) 3022 continue; 3023 if (best == NULL) 3024 best = pkt_dev; 3025 else if (pkt_dev->next_tx_us < best->next_tx_us) 3026 best = pkt_dev; 3027 } 3028 if_unlock(t); 3029 return best; 3030 } 3031 3032 static void pktgen_stop(struct pktgen_thread *t) 3033 { 3034 struct pktgen_dev *pkt_dev; 3035 3036 pr_debug("pktgen: entering pktgen_stop\n"); 3037 3038 if_lock(t); 3039 3040 list_for_each_entry(pkt_dev, &t->if_list, list) { 3041 pktgen_stop_device(pkt_dev); 3042 if (pkt_dev->skb) 3043 kfree_skb(pkt_dev->skb); 3044 3045 pkt_dev->skb = NULL; 3046 } 3047 3048 if_unlock(t); 3049 } 3050 3051 /* 3052 * one of our devices needs to be removed - find it 3053 * and remove it 3054 */ 3055 static void pktgen_rem_one_if(struct pktgen_thread *t) 3056 { 3057 struct list_head *q, *n; 3058 struct pktgen_dev *cur; 3059 3060 pr_debug("pktgen: entering pktgen_rem_one_if\n"); 3061 3062 if_lock(t); 3063 3064 list_for_each_safe(q, n, &t->if_list) { 3065 cur = list_entry(q, struct pktgen_dev, list); 3066 3067 if (!cur->removal_mark) 3068 continue; 3069 3070 if (cur->skb) 3071 kfree_skb(cur->skb); 3072 cur->skb = NULL; 3073 3074 pktgen_remove_device(t, cur); 3075 3076 break; 3077 } 3078 3079 if_unlock(t); 3080 } 3081 3082 static void pktgen_rem_all_ifs(struct pktgen_thread *t) 3083 { 3084 struct list_head *q, *n; 3085 struct pktgen_dev *cur; 3086 3087 /* Remove all devices, free mem */ 3088 3089 pr_debug("pktgen: entering pktgen_rem_all_ifs\n"); 3090 if_lock(t); 3091 3092 list_for_each_safe(q, n, &t->if_list) { 3093 cur = list_entry(q, struct pktgen_dev, list); 3094 3095 if (cur->skb) 3096 kfree_skb(cur->skb); 3097 cur->skb = NULL; 3098 3099 pktgen_remove_device(t, cur); 3100 } 3101 3102 if_unlock(t); 3103 } 3104 3105 static void pktgen_rem_thread(struct pktgen_thread *t) 3106 { 3107 /* Remove from the thread list */ 3108 3109 remove_proc_entry(t->tsk->comm, pg_proc_dir); 3110 3111 mutex_lock(&pktgen_thread_lock); 3112 3113 list_del(&t->th_list); 3114 3115 mutex_unlock(&pktgen_thread_lock); 3116 } 3117 3118 static __inline__ void pktgen_xmit(struct pktgen_dev *pkt_dev) 3119 { 3120 struct net_device *odev = NULL; 3121 __u64 idle_start = 0; 3122 int ret; 3123 3124 odev = pkt_dev->odev; 3125 3126 if (pkt_dev->delay_us || pkt_dev->delay_ns) { 3127 u64 now; 3128 3129 now = getCurUs(); 3130 if (now < pkt_dev->next_tx_us) 3131 spin(pkt_dev, pkt_dev->next_tx_us); 3132 3133 /* This is max DELAY, this has special meaning of 3134 * "never transmit" 3135 */ 3136 if (pkt_dev->delay_us == 0x7FFFFFFF) { 3137 pkt_dev->next_tx_us = getCurUs() + pkt_dev->delay_us; 3138 pkt_dev->next_tx_ns = pkt_dev->delay_ns; 3139 goto out; 3140 } 3141 } 3142 3143 if (netif_queue_stopped(odev) || need_resched()) { 3144 idle_start = getCurUs(); 3145 3146 if (!netif_running(odev)) { 3147 pktgen_stop_device(pkt_dev); 3148 if (pkt_dev->skb) 3149 kfree_skb(pkt_dev->skb); 3150 pkt_dev->skb = NULL; 3151 goto out; 3152 } 3153 if (need_resched()) 3154 schedule(); 3155 3156 pkt_dev->idle_acc += getCurUs() - idle_start; 3157 3158 if (netif_queue_stopped(odev)) { 3159 pkt_dev->next_tx_us = getCurUs(); /* TODO */ 3160 pkt_dev->next_tx_ns = 0; 3161 goto out; /* Try the next interface */ 3162 } 3163 } 3164 3165 if (pkt_dev->last_ok || !pkt_dev->skb) { 3166 if ((++pkt_dev->clone_count >= pkt_dev->clone_skb) 3167 || (!pkt_dev->skb)) { 3168 /* build a new pkt */ 3169 if (pkt_dev->skb) 3170 kfree_skb(pkt_dev->skb); 3171 3172 pkt_dev->skb = fill_packet(odev, pkt_dev); 3173 if (pkt_dev->skb == NULL) { 3174 printk("pktgen: ERROR: couldn't allocate skb in fill_packet.\n"); 3175 schedule(); 3176 pkt_dev->clone_count--; /* back out increment, OOM */ 3177 goto out; 3178 } 3179 pkt_dev->allocated_skbs++; 3180 pkt_dev->clone_count = 0; /* reset counter */ 3181 } 3182 } 3183 3184 netif_tx_lock_bh(odev); 3185 if (!netif_queue_stopped(odev)) { 3186 3187 atomic_inc(&(pkt_dev->skb->users)); 3188 retry_now: 3189 ret = odev->hard_start_xmit(pkt_dev->skb, odev); 3190 if (likely(ret == NETDEV_TX_OK)) { 3191 pkt_dev->last_ok = 1; 3192 pkt_dev->sofar++; 3193 pkt_dev->seq_num++; 3194 pkt_dev->tx_bytes += pkt_dev->cur_pkt_size; 3195 3196 } else if (ret == NETDEV_TX_LOCKED 3197 && (odev->features & NETIF_F_LLTX)) { 3198 cpu_relax(); 3199 goto retry_now; 3200 } else { /* Retry it next time */ 3201 3202 atomic_dec(&(pkt_dev->skb->users)); 3203 3204 if (debug && net_ratelimit()) 3205 printk(KERN_INFO "pktgen: Hard xmit error\n"); 3206 3207 pkt_dev->errors++; 3208 pkt_dev->last_ok = 0; 3209 } 3210 3211 pkt_dev->next_tx_us = getCurUs(); 3212 pkt_dev->next_tx_ns = 0; 3213 3214 pkt_dev->next_tx_us += pkt_dev->delay_us; 3215 pkt_dev->next_tx_ns += pkt_dev->delay_ns; 3216 3217 if (pkt_dev->next_tx_ns > 1000) { 3218 pkt_dev->next_tx_us++; 3219 pkt_dev->next_tx_ns -= 1000; 3220 } 3221 } 3222 3223 else { /* Retry it next time */ 3224 pkt_dev->last_ok = 0; 3225 pkt_dev->next_tx_us = getCurUs(); /* TODO */ 3226 pkt_dev->next_tx_ns = 0; 3227 } 3228 3229 netif_tx_unlock_bh(odev); 3230 3231 /* If pkt_dev->count is zero, then run forever */ 3232 if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) { 3233 if (atomic_read(&(pkt_dev->skb->users)) != 1) { 3234 idle_start = getCurUs(); 3235 while (atomic_read(&(pkt_dev->skb->users)) != 1) { 3236 if (signal_pending(current)) { 3237 break; 3238 } 3239 schedule(); 3240 } 3241 pkt_dev->idle_acc += getCurUs() - idle_start; 3242 } 3243 3244 /* Done with this */ 3245 pktgen_stop_device(pkt_dev); 3246 if (pkt_dev->skb) 3247 kfree_skb(pkt_dev->skb); 3248 pkt_dev->skb = NULL; 3249 } 3250 out:; 3251 } 3252 3253 /* 3254 * Main loop of the thread goes here 3255 */ 3256 3257 static int pktgen_thread_worker(void *arg) 3258 { 3259 DEFINE_WAIT(wait); 3260 struct pktgen_thread *t = arg; 3261 struct pktgen_dev *pkt_dev = NULL; 3262 int cpu = t->cpu; 3263 u32 max_before_softirq; 3264 u32 tx_since_softirq = 0; 3265 3266 BUG_ON(smp_processor_id() != cpu); 3267 3268 init_waitqueue_head(&t->queue); 3269 3270 t->pid = current->pid; 3271 3272 pr_debug("pktgen: starting pktgen/%d: pid=%d\n", cpu, current->pid); 3273 3274 max_before_softirq = t->max_before_softirq; 3275 3276 set_current_state(TASK_INTERRUPTIBLE); 3277 3278 while (!kthread_should_stop()) { 3279 pkt_dev = next_to_run(t); 3280 3281 if (!pkt_dev && 3282 (t->control & (T_STOP | T_RUN | T_REMDEVALL | T_REMDEV)) 3283 == 0) { 3284 prepare_to_wait(&(t->queue), &wait, 3285 TASK_INTERRUPTIBLE); 3286 schedule_timeout(HZ / 10); 3287 finish_wait(&(t->queue), &wait); 3288 } 3289 3290 __set_current_state(TASK_RUNNING); 3291 3292 if (pkt_dev) { 3293 3294 pktgen_xmit(pkt_dev); 3295 3296 /* 3297 * We like to stay RUNNING but must also give 3298 * others fair share. 3299 */ 3300 3301 tx_since_softirq += pkt_dev->last_ok; 3302 3303 if (tx_since_softirq > max_before_softirq) { 3304 if (local_softirq_pending()) 3305 do_softirq(); 3306 tx_since_softirq = 0; 3307 } 3308 } 3309 3310 if (t->control & T_STOP) { 3311 pktgen_stop(t); 3312 t->control &= ~(T_STOP); 3313 } 3314 3315 if (t->control & T_RUN) { 3316 pktgen_run(t); 3317 t->control &= ~(T_RUN); 3318 } 3319 3320 if (t->control & T_REMDEVALL) { 3321 pktgen_rem_all_ifs(t); 3322 t->control &= ~(T_REMDEVALL); 3323 } 3324 3325 if (t->control & T_REMDEV) { 3326 pktgen_rem_one_if(t); 3327 t->control &= ~(T_REMDEV); 3328 } 3329 3330 try_to_freeze(); 3331 3332 set_current_state(TASK_INTERRUPTIBLE); 3333 } 3334 3335 pr_debug("pktgen: %s stopping all device\n", t->tsk->comm); 3336 pktgen_stop(t); 3337 3338 pr_debug("pktgen: %s removing all device\n", t->tsk->comm); 3339 pktgen_rem_all_ifs(t); 3340 3341 pr_debug("pktgen: %s removing thread.\n", t->tsk->comm); 3342 pktgen_rem_thread(t); 3343 3344 return 0; 3345 } 3346 3347 static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t, 3348 const char *ifname) 3349 { 3350 struct pktgen_dev *p, *pkt_dev = NULL; 3351 if_lock(t); 3352 3353 list_for_each_entry(p, &t->if_list, list) 3354 if (strncmp(p->odev->name, ifname, IFNAMSIZ) == 0) { 3355 pkt_dev = p; 3356 break; 3357 } 3358 3359 if_unlock(t); 3360 pr_debug("pktgen: find_dev(%s) returning %p\n", ifname, pkt_dev); 3361 return pkt_dev; 3362 } 3363 3364 /* 3365 * Adds a dev at front of if_list. 3366 */ 3367 3368 static int add_dev_to_thread(struct pktgen_thread *t, 3369 struct pktgen_dev *pkt_dev) 3370 { 3371 int rv = 0; 3372 3373 if_lock(t); 3374 3375 if (pkt_dev->pg_thread) { 3376 printk("pktgen: ERROR: already assigned to a thread.\n"); 3377 rv = -EBUSY; 3378 goto out; 3379 } 3380 3381 list_add(&pkt_dev->list, &t->if_list); 3382 pkt_dev->pg_thread = t; 3383 pkt_dev->running = 0; 3384 3385 out: 3386 if_unlock(t); 3387 return rv; 3388 } 3389 3390 /* Called under thread lock */ 3391 3392 static int pktgen_add_device(struct pktgen_thread *t, const char *ifname) 3393 { 3394 struct pktgen_dev *pkt_dev; 3395 int err; 3396 3397 /* We don't allow a device to be on several threads */ 3398 3399 pkt_dev = __pktgen_NN_threads(ifname, FIND); 3400 if (pkt_dev) { 3401 printk("pktgen: ERROR: interface already used.\n"); 3402 return -EBUSY; 3403 } 3404 3405 pkt_dev = kzalloc(sizeof(struct pktgen_dev), GFP_KERNEL); 3406 if (!pkt_dev) 3407 return -ENOMEM; 3408 3409 pkt_dev->flows = vmalloc(MAX_CFLOWS * sizeof(struct flow_state)); 3410 if (pkt_dev->flows == NULL) { 3411 kfree(pkt_dev); 3412 return -ENOMEM; 3413 } 3414 memset(pkt_dev->flows, 0, MAX_CFLOWS * sizeof(struct flow_state)); 3415 3416 pkt_dev->removal_mark = 0; 3417 pkt_dev->min_pkt_size = ETH_ZLEN; 3418 pkt_dev->max_pkt_size = ETH_ZLEN; 3419 pkt_dev->nfrags = 0; 3420 pkt_dev->clone_skb = pg_clone_skb_d; 3421 pkt_dev->delay_us = pg_delay_d / 1000; 3422 pkt_dev->delay_ns = pg_delay_d % 1000; 3423 pkt_dev->count = pg_count_d; 3424 pkt_dev->sofar = 0; 3425 pkt_dev->udp_src_min = 9; /* sink port */ 3426 pkt_dev->udp_src_max = 9; 3427 pkt_dev->udp_dst_min = 9; 3428 pkt_dev->udp_dst_max = 9; 3429 3430 pkt_dev->vlan_p = 0; 3431 pkt_dev->vlan_cfi = 0; 3432 pkt_dev->vlan_id = 0xffff; 3433 pkt_dev->svlan_p = 0; 3434 pkt_dev->svlan_cfi = 0; 3435 pkt_dev->svlan_id = 0xffff; 3436 3437 err = pktgen_setup_dev(pkt_dev, ifname); 3438 if (err) 3439 goto out1; 3440 3441 pkt_dev->entry = create_proc_entry(ifname, 0600, pg_proc_dir); 3442 if (!pkt_dev->entry) { 3443 printk("pktgen: cannot create %s/%s procfs entry.\n", 3444 PG_PROC_DIR, ifname); 3445 err = -EINVAL; 3446 goto out2; 3447 } 3448 pkt_dev->entry->proc_fops = &pktgen_if_fops; 3449 pkt_dev->entry->data = pkt_dev; 3450 3451 return add_dev_to_thread(t, pkt_dev); 3452 out2: 3453 dev_put(pkt_dev->odev); 3454 out1: 3455 if (pkt_dev->flows) 3456 vfree(pkt_dev->flows); 3457 kfree(pkt_dev); 3458 return err; 3459 } 3460 3461 static int __init pktgen_create_thread(int cpu) 3462 { 3463 struct pktgen_thread *t; 3464 struct proc_dir_entry *pe; 3465 struct task_struct *p; 3466 3467 t = kzalloc(sizeof(struct pktgen_thread), GFP_KERNEL); 3468 if (!t) { 3469 printk("pktgen: ERROR: out of memory, can't create new thread.\n"); 3470 return -ENOMEM; 3471 } 3472 3473 spin_lock_init(&t->if_lock); 3474 t->cpu = cpu; 3475 3476 INIT_LIST_HEAD(&t->if_list); 3477 3478 list_add_tail(&t->th_list, &pktgen_threads); 3479 3480 p = kthread_create(pktgen_thread_worker, t, "kpktgend_%d", cpu); 3481 if (IS_ERR(p)) { 3482 printk("pktgen: kernel_thread() failed for cpu %d\n", t->cpu); 3483 list_del(&t->th_list); 3484 kfree(t); 3485 return PTR_ERR(p); 3486 } 3487 kthread_bind(p, cpu); 3488 t->tsk = p; 3489 3490 pe = create_proc_entry(t->tsk->comm, 0600, pg_proc_dir); 3491 if (!pe) { 3492 printk("pktgen: cannot create %s/%s procfs entry.\n", 3493 PG_PROC_DIR, t->tsk->comm); 3494 kthread_stop(p); 3495 list_del(&t->th_list); 3496 kfree(t); 3497 return -EINVAL; 3498 } 3499 3500 pe->proc_fops = &pktgen_thread_fops; 3501 pe->data = t; 3502 3503 wake_up_process(p); 3504 3505 return 0; 3506 } 3507 3508 /* 3509 * Removes a device from the thread if_list. 3510 */ 3511 static void _rem_dev_from_if_list(struct pktgen_thread *t, 3512 struct pktgen_dev *pkt_dev) 3513 { 3514 struct list_head *q, *n; 3515 struct pktgen_dev *p; 3516 3517 list_for_each_safe(q, n, &t->if_list) { 3518 p = list_entry(q, struct pktgen_dev, list); 3519 if (p == pkt_dev) 3520 list_del(&p->list); 3521 } 3522 } 3523 3524 static int pktgen_remove_device(struct pktgen_thread *t, 3525 struct pktgen_dev *pkt_dev) 3526 { 3527 3528 pr_debug("pktgen: remove_device pkt_dev=%p\n", pkt_dev); 3529 3530 if (pkt_dev->running) { 3531 printk("pktgen:WARNING: trying to remove a running interface, stopping it now.\n"); 3532 pktgen_stop_device(pkt_dev); 3533 } 3534 3535 /* Dis-associate from the interface */ 3536 3537 if (pkt_dev->odev) { 3538 dev_put(pkt_dev->odev); 3539 pkt_dev->odev = NULL; 3540 } 3541 3542 /* And update the thread if_list */ 3543 3544 _rem_dev_from_if_list(t, pkt_dev); 3545 3546 if (pkt_dev->entry) 3547 remove_proc_entry(pkt_dev->entry->name, pg_proc_dir); 3548 3549 if (pkt_dev->flows) 3550 vfree(pkt_dev->flows); 3551 kfree(pkt_dev); 3552 return 0; 3553 } 3554 3555 static int __init pg_init(void) 3556 { 3557 int cpu; 3558 struct proc_dir_entry *pe; 3559 3560 printk(version); 3561 3562 pg_proc_dir = proc_mkdir(PG_PROC_DIR, proc_net); 3563 if (!pg_proc_dir) 3564 return -ENODEV; 3565 pg_proc_dir->owner = THIS_MODULE; 3566 3567 pe = create_proc_entry(PGCTRL, 0600, pg_proc_dir); 3568 if (pe == NULL) { 3569 printk("pktgen: ERROR: cannot create %s procfs entry.\n", 3570 PGCTRL); 3571 proc_net_remove(PG_PROC_DIR); 3572 return -EINVAL; 3573 } 3574 3575 pe->proc_fops = &pktgen_fops; 3576 pe->data = NULL; 3577 3578 /* Register us to receive netdevice events */ 3579 register_netdevice_notifier(&pktgen_notifier_block); 3580 3581 for_each_online_cpu(cpu) { 3582 int err; 3583 3584 err = pktgen_create_thread(cpu); 3585 if (err) 3586 printk("pktgen: WARNING: Cannot create thread for cpu %d (%d)\n", 3587 cpu, err); 3588 } 3589 3590 if (list_empty(&pktgen_threads)) { 3591 printk("pktgen: ERROR: Initialization failed for all threads\n"); 3592 unregister_netdevice_notifier(&pktgen_notifier_block); 3593 remove_proc_entry(PGCTRL, pg_proc_dir); 3594 proc_net_remove(PG_PROC_DIR); 3595 return -ENODEV; 3596 } 3597 3598 return 0; 3599 } 3600 3601 static void __exit pg_cleanup(void) 3602 { 3603 struct pktgen_thread *t; 3604 struct list_head *q, *n; 3605 wait_queue_head_t queue; 3606 init_waitqueue_head(&queue); 3607 3608 /* Stop all interfaces & threads */ 3609 3610 list_for_each_safe(q, n, &pktgen_threads) { 3611 t = list_entry(q, struct pktgen_thread, th_list); 3612 kthread_stop(t->tsk); 3613 kfree(t); 3614 } 3615 3616 /* Un-register us from receiving netdevice events */ 3617 unregister_netdevice_notifier(&pktgen_notifier_block); 3618 3619 /* Clean up proc file system */ 3620 remove_proc_entry(PGCTRL, pg_proc_dir); 3621 proc_net_remove(PG_PROC_DIR); 3622 } 3623 3624 module_init(pg_init); 3625 module_exit(pg_cleanup); 3626 3627 MODULE_AUTHOR("Robert Olsson <robert.olsson@its.uu.se"); 3628 MODULE_DESCRIPTION("Packet Generator tool"); 3629 MODULE_LICENSE("GPL"); 3630 module_param(pg_count_d, int, 0); 3631 module_param(pg_delay_d, int, 0); 3632 module_param(pg_clone_skb_d, int, 0); 3633 module_param(debug, int, 0); 3634