pktgen.c (64e8ff5ef2a798cae2e3bede75644173aae98e08) pktgen.c (63adc6fb8ac0dee0020d6ad73e0d44f4306e1e34)
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>

--- 149 unchanged lines hidden (view full) ---

158#include <net/ipv6.h>
159#include <net/addrconf.h>
160#ifdef CONFIG_XFRM
161#include <net/xfrm.h>
162#endif
163#include <asm/byteorder.h>
164#include <linux/rcupdate.h>
165#include <linux/bitops.h>
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>

--- 149 unchanged lines hidden (view full) ---

158#include <net/ipv6.h>
159#include <net/addrconf.h>
160#ifdef CONFIG_XFRM
161#include <net/xfrm.h>
162#endif
163#include <asm/byteorder.h>
164#include <linux/rcupdate.h>
165#include <linux/bitops.h>
166#include <asm/io.h>
166#include <linux/io.h>
167#include <linux/timex.h>
168#include <linux/uaccess.h>
167#include <asm/dma.h>
169#include <asm/dma.h>
168#include <asm/uaccess.h>
169#include <asm/div64.h> /* do_div */
170#include <asm/div64.h> /* do_div */
170#include <asm/timex.h>
171
171
172#define VERSION "pktgen v2.70: Packet Generator for packet performance testing.\n"
172#define VERSION \
173 "pktgen v2.70: Packet Generator for packet performance testing.\n"
173
174#define IP_NAME_SZ 32
175#define MAX_MPLS_LABELS 16 /* This is the max label stack depth */
176#define MPLS_STACK_BOTTOM htonl(0x00000100)
177
178/* Device flag bits */
179#define F_IPSRC_RND (1<<0) /* IP-Src Random */
180#define F_IPDST_RND (1<<1) /* IP-Dst Random */

--- 21 unchanged lines hidden (view full) ---

202/* If lock -- can be removed after some work */
203#define if_lock(t) spin_lock(&(t->if_lock));
204#define if_unlock(t) spin_unlock(&(t->if_lock));
205
206/* Used to help with determining the pkts on receive */
207#define PKTGEN_MAGIC 0xbe9be955
208#define PG_PROC_DIR "pktgen"
209#define PGCTRL "pgctrl"
174
175#define IP_NAME_SZ 32
176#define MAX_MPLS_LABELS 16 /* This is the max label stack depth */
177#define MPLS_STACK_BOTTOM htonl(0x00000100)
178
179/* Device flag bits */
180#define F_IPSRC_RND (1<<0) /* IP-Src Random */
181#define F_IPDST_RND (1<<1) /* IP-Dst Random */

--- 21 unchanged lines hidden (view full) ---

203/* If lock -- can be removed after some work */
204#define if_lock(t) spin_lock(&(t->if_lock));
205#define if_unlock(t) spin_unlock(&(t->if_lock));
206
207/* Used to help with determining the pkts on receive */
208#define PKTGEN_MAGIC 0xbe9be955
209#define PG_PROC_DIR "pktgen"
210#define PGCTRL "pgctrl"
210static struct proc_dir_entry *pg_proc_dir = NULL;
211static struct proc_dir_entry *pg_proc_dir;
211
212#define MAX_CFLOWS 65536
213
214#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
215#define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
216
217struct flow_state {
218 __be32 cur_daddr;

--- 8 unchanged lines hidden (view full) ---

227#define F_INIT (1<<0) /* flow has been initialized */
228
229struct pktgen_dev {
230 /*
231 * Try to keep frequent/infrequent used vars. separated.
232 */
233 struct proc_dir_entry *entry; /* proc file */
234 struct pktgen_thread *pg_thread;/* the owner */
212
213#define MAX_CFLOWS 65536
214
215#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
216#define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
217
218struct flow_state {
219 __be32 cur_daddr;

--- 8 unchanged lines hidden (view full) ---

228#define F_INIT (1<<0) /* flow has been initialized */
229
230struct pktgen_dev {
231 /*
232 * Try to keep frequent/infrequent used vars. separated.
233 */
234 struct proc_dir_entry *entry; /* proc file */
235 struct pktgen_thread *pg_thread;/* the owner */
235 struct list_head list; /* Used for chaining in the thread's run-queue */
236 struct list_head list; /* chaining in the thread's run-queue */
236
237
237 int running; /* if this changes to false, the test will stop */
238 int running; /* if false, the test will stop */
238
239 /* If min != max, then we will either do a linear iteration, or
240 * we will do a random selection from within the range.
241 */
242 __u32 flags;
243 int removal_mark; /* non-zero => the device is marked for
244 * removal by worker thread */
245
246 int min_pkt_size; /* = ETH_ZLEN; */
247 int max_pkt_size; /* = ETH_ZLEN; */
248 int pkt_overhead; /* overhead for MPLS, VLANs, IPSEC etc */
249 int nfrags;
250 u64 delay; /* nano-seconds */
251
252 __u64 count; /* Default No packets to send */
253 __u64 sofar; /* How many pkts we've sent so far */
254 __u64 tx_bytes; /* How many bytes we've transmitted */
239
240 /* If min != max, then we will either do a linear iteration, or
241 * we will do a random selection from within the range.
242 */
243 __u32 flags;
244 int removal_mark; /* non-zero => the device is marked for
245 * removal by worker thread */
246
247 int min_pkt_size; /* = ETH_ZLEN; */
248 int max_pkt_size; /* = ETH_ZLEN; */
249 int pkt_overhead; /* overhead for MPLS, VLANs, IPSEC etc */
250 int nfrags;
251 u64 delay; /* nano-seconds */
252
253 __u64 count; /* Default No packets to send */
254 __u64 sofar; /* How many pkts we've sent so far */
255 __u64 tx_bytes; /* How many bytes we've transmitted */
255 __u64 errors; /* Errors when trying to transmit, pkts will be re-sent */
256 __u64 errors; /* Errors when trying to transmit,
257 pkts will be re-sent */
256
257 /* runtime counters relating to clone_skb */
258
259 __u64 allocated_skbs;
260 __u32 clone_count;
261 int last_ok; /* Was last skb sent?
258
259 /* runtime counters relating to clone_skb */
260
261 __u64 allocated_skbs;
262 __u32 clone_count;
263 int last_ok; /* Was last skb sent?
262 * Or a failed transmit of some sort? This will keep
263 * sequence numbers in order, for example.
264 * Or a failed transmit of some sort?
265 * This will keep sequence numbers in order
264 */
265 ktime_t next_tx;
266 ktime_t started_at;
267 ktime_t stopped_at;
268 u64 idle_acc; /* nano-seconds */
269
270 __u32 seq_num;
271
266 */
267 ktime_t next_tx;
268 ktime_t started_at;
269 ktime_t stopped_at;
270 u64 idle_acc; /* nano-seconds */
271
272 __u32 seq_num;
273
272 int clone_skb; /* Use multiple SKBs during packet gen. If this number
273 * is greater than 1, then that many copies of the same
274 * packet will be sent before a new packet is allocated.
275 * For instance, if you want to send 1024 identical packets
276 * before creating a new packet, set clone_skb to 1024.
274 int clone_skb; /*
275 * Use multiple SKBs during packet gen.
276 * If this number is greater than 1, then
277 * that many copies of the same packet will be
278 * sent before a new packet is allocated.
279 * If you want to send 1024 identical packets
280 * before creating a new packet,
281 * set clone_skb to 1024.
277 */
278
279 char dst_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
280 char dst_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
281 char src_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
282 char src_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
283
284 struct in6_addr in6_saddr;

--- 15 unchanged lines hidden (view full) ---

300 __be32 daddr_max; /* exclusive, dest IP address */
301
302 __u16 udp_src_min; /* inclusive, source UDP port */
303 __u16 udp_src_max; /* exclusive, source UDP port */
304 __u16 udp_dst_min; /* inclusive, dest UDP port */
305 __u16 udp_dst_max; /* exclusive, dest UDP port */
306
307 /* DSCP + ECN */
282 */
283
284 char dst_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
285 char dst_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
286 char src_min[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
287 char src_max[IP_NAME_SZ]; /* IP, ie 1.2.3.4 */
288
289 struct in6_addr in6_saddr;

--- 15 unchanged lines hidden (view full) ---

305 __be32 daddr_max; /* exclusive, dest IP address */
306
307 __u16 udp_src_min; /* inclusive, source UDP port */
308 __u16 udp_src_max; /* exclusive, source UDP port */
309 __u16 udp_dst_min; /* inclusive, dest UDP port */
310 __u16 udp_dst_max; /* exclusive, dest UDP port */
311
312 /* DSCP + ECN */
308 __u8 tos; /* six most significant bits of (former) IPv4 TOS are for dscp codepoint */
309 __u8 traffic_class; /* ditto for the (former) Traffic Class in IPv6 (see RFC 3260, sec. 4) */
313 __u8 tos; /* six MSB of (former) IPv4 TOS
314 are for dscp codepoint */
315 __u8 traffic_class; /* ditto for the (former) Traffic Class in IPv6
316 (see RFC 3260, sec. 4) */
310
311 /* MPLS */
312 unsigned nr_labels; /* Depth of stack, 0 = no MPLS */
313 __be32 labels[MAX_MPLS_LABELS];
314
315 /* VLAN/SVLAN (802.1Q/Q-in-Q) */
316 __u8 vlan_p;
317 __u8 vlan_cfi;

--- 24 unchanged lines hidden (view full) ---

342
343 We fill in SRC address later
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
345 0x08, 0x00
346 };
347 */
348 __u16 pad; /* pad out the hh struct to an even 16 bytes */
349
317
318 /* MPLS */
319 unsigned nr_labels; /* Depth of stack, 0 = no MPLS */
320 __be32 labels[MAX_MPLS_LABELS];
321
322 /* VLAN/SVLAN (802.1Q/Q-in-Q) */
323 __u8 vlan_p;
324 __u8 vlan_cfi;

--- 24 unchanged lines hidden (view full) ---

349
350 We fill in SRC address later
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
352 0x08, 0x00
353 };
354 */
355 __u16 pad; /* pad out the hh struct to an even 16 bytes */
356
350 struct sk_buff *skb; /* skb we are to transmit next, mainly used for when we
357 struct sk_buff *skb; /* skb we are to transmit next, used for when we
351 * are transmitting the same one multiple times
352 */
358 * are transmitting the same one multiple times
359 */
353 struct net_device *odev; /* The out-going device. Note that the device should
354 * have it's pg_info pointer pointing back to this
355 * device. This will be set when the user specifies
356 * the out-going device name (not when the inject is
357 * started as it used to do.)
358 */
360 struct net_device *odev; /* The out-going device.
361 * Note that the device should have it's
362 * pg_info pointer pointing back to this
363 * device.
364 * Set when the user specifies the out-going
365 * device name (not when the inject is
366 * started as it used to do.)
367 */
359 struct flow_state *flows;
360 unsigned cflows; /* Concurrent flows (config) */
361 unsigned lflow; /* Flow length (config) */
362 unsigned nflows; /* accumulated flows (stats) */
363 unsigned curfl; /* current sequenced flow (state)*/
364
365 u16 queue_map_min;
366 u16 queue_map_max;

--- 8 unchanged lines hidden (view full) ---

375struct pktgen_hdr {
376 __be32 pgh_magic;
377 __be32 seq_num;
378 __be32 tv_sec;
379 __be32 tv_usec;
380};
381
382struct pktgen_thread {
368 struct flow_state *flows;
369 unsigned cflows; /* Concurrent flows (config) */
370 unsigned lflow; /* Flow length (config) */
371 unsigned nflows; /* accumulated flows (stats) */
372 unsigned curfl; /* current sequenced flow (state)*/
373
374 u16 queue_map_min;
375 u16 queue_map_max;

--- 8 unchanged lines hidden (view full) ---

384struct pktgen_hdr {
385 __be32 pgh_magic;
386 __be32 seq_num;
387 __be32 tv_sec;
388 __be32 tv_usec;
389};
390
391struct pktgen_thread {
383 spinlock_t if_lock;
392 spinlock_t if_lock; /* for list of devices */
384 struct list_head if_list; /* All device here */
385 struct list_head th_list;
386 struct task_struct *tsk;
387 char result[512];
388
393 struct list_head if_list; /* All device here */
394 struct list_head th_list;
395 struct task_struct *tsk;
396 char result[512];
397
389 /* Field for thread to receive "posted" events terminate, stop ifs etc. */
398 /* Field for thread to receive "posted" events terminate,
399 stop ifs etc. */
390
391 u32 control;
392 int cpu;
393
394 wait_queue_head_t queue;
395 struct completion start_done;
396};
397

--- 50 unchanged lines hidden (view full) ---

448 */
449
450static int pgctrl_show(struct seq_file *seq, void *v)
451{
452 seq_puts(seq, VERSION);
453 return 0;
454}
455
400
401 u32 control;
402 int cpu;
403
404 wait_queue_head_t queue;
405 struct completion start_done;
406};
407

--- 50 unchanged lines hidden (view full) ---

458 */
459
460static int pgctrl_show(struct seq_file *seq, void *v)
461{
462 seq_puts(seq, VERSION);
463 return 0;
464}
465
456static ssize_t pgctrl_write(struct file *file, const char __user * buf,
457 size_t count, loff_t * ppos)
466static ssize_t pgctrl_write(struct file *file, const char __user *buf,
467 size_t count, loff_t *ppos)
458{
459 int err = 0;
460 char data[128];
461
462 if (!capable(CAP_NET_ADMIN)) {
463 err = -EPERM;
464 goto out;
465 }

--- 74 unchanged lines hidden (view full) ---

540
541 fmt_ip6(b1, pkt_dev->in6_daddr.s6_addr);
542 fmt_ip6(b2, pkt_dev->min_in6_daddr.s6_addr);
543 fmt_ip6(b3, pkt_dev->max_in6_daddr.s6_addr);
544 seq_printf(seq,
545 " daddr: %s min_daddr: %s max_daddr: %s\n", b1,
546 b2, b3);
547
468{
469 int err = 0;
470 char data[128];
471
472 if (!capable(CAP_NET_ADMIN)) {
473 err = -EPERM;
474 goto out;
475 }

--- 74 unchanged lines hidden (view full) ---

550
551 fmt_ip6(b1, pkt_dev->in6_daddr.s6_addr);
552 fmt_ip6(b2, pkt_dev->min_in6_daddr.s6_addr);
553 fmt_ip6(b3, pkt_dev->max_in6_daddr.s6_addr);
554 seq_printf(seq,
555 " daddr: %s min_daddr: %s max_daddr: %s\n", b1,
556 b2, b3);
557
548 } else
558 } else {
549 seq_printf(seq,
559 seq_printf(seq,
550 " dst_min: %s dst_max: %s\n src_min: %s src_max: %s\n",
551 pkt_dev->dst_min, pkt_dev->dst_max, pkt_dev->src_min,
552 pkt_dev->src_max);
560 " dst_min: %s dst_max: %s\n",
561 pkt_dev->dst_min, pkt_dev->dst_max);
562 seq_printf(seq,
563 " src_min: %s src_max: %s\n",
564 pkt_dev->src_min, pkt_dev->src_max);
565 }
553
554 seq_puts(seq, " src_mac: ");
555
556 seq_printf(seq, "%pM ",
557 is_zero_ether_addr(pkt_dev->src_mac) ?
558 pkt_dev->odev->dev_addr : pkt_dev->src_mac);
559
560 seq_printf(seq, "dst_mac: ");
561 seq_printf(seq, "%pM\n", pkt_dev->dst_mac);
562
563 seq_printf(seq,
566
567 seq_puts(seq, " src_mac: ");
568
569 seq_printf(seq, "%pM ",
570 is_zero_ether_addr(pkt_dev->src_mac) ?
571 pkt_dev->odev->dev_addr : pkt_dev->src_mac);
572
573 seq_printf(seq, "dst_mac: ");
574 seq_printf(seq, "%pM\n", pkt_dev->dst_mac);
575
576 seq_printf(seq,
564 " udp_src_min: %d udp_src_max: %d udp_dst_min: %d udp_dst_max: %d\n",
577 " udp_src_min: %d udp_src_max: %d"
578 " udp_dst_min: %d udp_dst_max: %d\n",
565 pkt_dev->udp_src_min, pkt_dev->udp_src_max,
566 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
567
568 seq_printf(seq,
569 " src_mac_count: %d dst_mac_count: %d\n",
570 pkt_dev->src_mac_count, pkt_dev->dst_mac_count);
571
572 if (pkt_dev->nr_labels) {
573 unsigned i;
574 seq_printf(seq, " mpls: ");
575 for (i = 0; i < pkt_dev->nr_labels; i++)
576 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
577 i == pkt_dev->nr_labels-1 ? "\n" : ", ");
578 }
579
579 pkt_dev->udp_src_min, pkt_dev->udp_src_max,
580 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
581
582 seq_printf(seq,
583 " src_mac_count: %d dst_mac_count: %d\n",
584 pkt_dev->src_mac_count, pkt_dev->dst_mac_count);
585
586 if (pkt_dev->nr_labels) {
587 unsigned i;
588 seq_printf(seq, " mpls: ");
589 for (i = 0; i < pkt_dev->nr_labels; i++)
590 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
591 i == pkt_dev->nr_labels-1 ? "\n" : ", ");
592 }
593
580 if (pkt_dev->vlan_id != 0xffff) {
594 if (pkt_dev->vlan_id != 0xffff)
581 seq_printf(seq, " vlan_id: %u vlan_p: %u vlan_cfi: %u\n",
595 seq_printf(seq, " vlan_id: %u vlan_p: %u vlan_cfi: %u\n",
582 pkt_dev->vlan_id, pkt_dev->vlan_p, pkt_dev->vlan_cfi);
583 }
596 pkt_dev->vlan_id, pkt_dev->vlan_p,
597 pkt_dev->vlan_cfi);
584
598
585 if (pkt_dev->svlan_id != 0xffff) {
599 if (pkt_dev->svlan_id != 0xffff)
586 seq_printf(seq, " svlan_id: %u vlan_p: %u vlan_cfi: %u\n",
600 seq_printf(seq, " svlan_id: %u vlan_p: %u vlan_cfi: %u\n",
587 pkt_dev->svlan_id, pkt_dev->svlan_p, pkt_dev->svlan_cfi);
588 }
601 pkt_dev->svlan_id, pkt_dev->svlan_p,
602 pkt_dev->svlan_cfi);
589
603
590 if (pkt_dev->tos) {
604 if (pkt_dev->tos)
591 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos);
605 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos);
592 }
593
606
594 if (pkt_dev->traffic_class) {
607 if (pkt_dev->traffic_class)
595 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class);
608 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class);
596 }
597
598 seq_printf(seq, " Flags: ");
599
600 if (pkt_dev->flags & F_IPV6)
601 seq_printf(seq, "IPV6 ");
602
603 if (pkt_dev->flags & F_IPSRC_RND)
604 seq_printf(seq, "IPSRC_RND ");

--- 86 unchanged lines hidden (view full) ---

691 seq_printf(seq, "Result: %s\n", pkt_dev->result);
692 else
693 seq_printf(seq, "Result: Idle\n");
694
695 return 0;
696}
697
698
609
610 seq_printf(seq, " Flags: ");
611
612 if (pkt_dev->flags & F_IPV6)
613 seq_printf(seq, "IPV6 ");
614
615 if (pkt_dev->flags & F_IPSRC_RND)
616 seq_printf(seq, "IPSRC_RND ");

--- 86 unchanged lines hidden (view full) ---

703 seq_printf(seq, "Result: %s\n", pkt_dev->result);
704 else
705 seq_printf(seq, "Result: Idle\n");
706
707 return 0;
708}
709
710
699static int hex32_arg(const char __user *user_buffer, unsigned long maxlen, __u32 *num)
711static int hex32_arg(const char __user *user_buffer, unsigned long maxlen,
712 __u32 *num)
700{
701 int i = 0;
702 *num = 0;
703
704 for (; i < maxlen; i++) {
705 char c;
706 *num <<= 4;
707 if (get_user(c, &user_buffer[i]))

--- 133 unchanged lines hidden (view full) ---

841 printk(KERN_WARNING "pktgen: illegal format\n");
842 return tmp;
843 }
844 i += tmp;
845
846 /* Read variable name */
847
848 len = strn_len(&user_buffer[i], sizeof(name) - 1);
713{
714 int i = 0;
715 *num = 0;
716
717 for (; i < maxlen; i++) {
718 char c;
719 *num <<= 4;
720 if (get_user(c, &user_buffer[i]))

--- 133 unchanged lines hidden (view full) ---

854 printk(KERN_WARNING "pktgen: illegal format\n");
855 return tmp;
856 }
857 i += tmp;
858
859 /* Read variable name */
860
861 len = strn_len(&user_buffer[i], sizeof(name) - 1);
849 if (len < 0) {
862 if (len < 0)
850 return len;
863 return len;
851 }
864
852 memset(name, 0, sizeof(name));
853 if (copy_from_user(name, &user_buffer[i], len))
854 return -EFAULT;
855 i += len;
856
857 max = count - i;
858 len = count_trail_chars(&user_buffer[i], max);
859 if (len < 0)

--- 7 unchanged lines hidden (view full) ---

867 return -EFAULT;
868 tb[count] = 0;
869 printk(KERN_DEBUG "pktgen: %s,%lu buffer -:%s:-\n", name,
870 (unsigned long)count, tb);
871 }
872
873 if (!strcmp(name, "min_pkt_size")) {
874 len = num_arg(&user_buffer[i], 10, &value);
865 memset(name, 0, sizeof(name));
866 if (copy_from_user(name, &user_buffer[i], len))
867 return -EFAULT;
868 i += len;
869
870 max = count - i;
871 len = count_trail_chars(&user_buffer[i], max);
872 if (len < 0)

--- 7 unchanged lines hidden (view full) ---

880 return -EFAULT;
881 tb[count] = 0;
882 printk(KERN_DEBUG "pktgen: %s,%lu buffer -:%s:-\n", name,
883 (unsigned long)count, tb);
884 }
885
886 if (!strcmp(name, "min_pkt_size")) {
887 len = num_arg(&user_buffer[i], 10, &value);
875 if (len < 0) {
888 if (len < 0)
876 return len;
889 return len;
877 }
890
878 i += len;
879 if (value < 14 + 20 + 8)
880 value = 14 + 20 + 8;
881 if (value != pkt_dev->min_pkt_size) {
882 pkt_dev->min_pkt_size = value;
883 pkt_dev->cur_pkt_size = value;
884 }
885 sprintf(pg_result, "OK: min_pkt_size=%u",
886 pkt_dev->min_pkt_size);
887 return count;
888 }
889
890 if (!strcmp(name, "max_pkt_size")) {
891 len = num_arg(&user_buffer[i], 10, &value);
891 i += len;
892 if (value < 14 + 20 + 8)
893 value = 14 + 20 + 8;
894 if (value != pkt_dev->min_pkt_size) {
895 pkt_dev->min_pkt_size = value;
896 pkt_dev->cur_pkt_size = value;
897 }
898 sprintf(pg_result, "OK: min_pkt_size=%u",
899 pkt_dev->min_pkt_size);
900 return count;
901 }
902
903 if (!strcmp(name, "max_pkt_size")) {
904 len = num_arg(&user_buffer[i], 10, &value);
892 if (len < 0) {
905 if (len < 0)
893 return len;
906 return len;
894 }
907
895 i += len;
896 if (value < 14 + 20 + 8)
897 value = 14 + 20 + 8;
898 if (value != pkt_dev->max_pkt_size) {
899 pkt_dev->max_pkt_size = value;
900 pkt_dev->cur_pkt_size = value;
901 }
902 sprintf(pg_result, "OK: max_pkt_size=%u",
903 pkt_dev->max_pkt_size);
904 return count;
905 }
906
907 /* Shortcut for min = max */
908
909 if (!strcmp(name, "pkt_size")) {
910 len = num_arg(&user_buffer[i], 10, &value);
908 i += len;
909 if (value < 14 + 20 + 8)
910 value = 14 + 20 + 8;
911 if (value != pkt_dev->max_pkt_size) {
912 pkt_dev->max_pkt_size = value;
913 pkt_dev->cur_pkt_size = value;
914 }
915 sprintf(pg_result, "OK: max_pkt_size=%u",
916 pkt_dev->max_pkt_size);
917 return count;
918 }
919
920 /* Shortcut for min = max */
921
922 if (!strcmp(name, "pkt_size")) {
923 len = num_arg(&user_buffer[i], 10, &value);
911 if (len < 0) {
924 if (len < 0)
912 return len;
925 return len;
913 }
926
914 i += len;
915 if (value < 14 + 20 + 8)
916 value = 14 + 20 + 8;
917 if (value != pkt_dev->min_pkt_size) {
918 pkt_dev->min_pkt_size = value;
919 pkt_dev->max_pkt_size = value;
920 pkt_dev->cur_pkt_size = value;
921 }
922 sprintf(pg_result, "OK: pkt_size=%u", pkt_dev->min_pkt_size);
923 return count;
924 }
925
926 if (!strcmp(name, "debug")) {
927 len = num_arg(&user_buffer[i], 10, &value);
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->max_pkt_size = value;
933 pkt_dev->cur_pkt_size = value;
934 }
935 sprintf(pg_result, "OK: pkt_size=%u", pkt_dev->min_pkt_size);
936 return count;
937 }
938
939 if (!strcmp(name, "debug")) {
940 len = num_arg(&user_buffer[i], 10, &value);
928 if (len < 0) {
941 if (len < 0)
929 return len;
942 return len;
930 }
943
931 i += len;
932 debug = value;
933 sprintf(pg_result, "OK: debug=%u", debug);
934 return count;
935 }
936
937 if (!strcmp(name, "frags")) {
938 len = num_arg(&user_buffer[i], 10, &value);
944 i += len;
945 debug = value;
946 sprintf(pg_result, "OK: debug=%u", debug);
947 return count;
948 }
949
950 if (!strcmp(name, "frags")) {
951 len = num_arg(&user_buffer[i], 10, &value);
939 if (len < 0) {
952 if (len < 0)
940 return len;
953 return len;
941 }
954
942 i += len;
943 pkt_dev->nfrags = value;
944 sprintf(pg_result, "OK: frags=%u", pkt_dev->nfrags);
945 return count;
946 }
947 if (!strcmp(name, "delay")) {
948 len = num_arg(&user_buffer[i], 10, &value);
955 i += len;
956 pkt_dev->nfrags = value;
957 sprintf(pg_result, "OK: frags=%u", pkt_dev->nfrags);
958 return count;
959 }
960 if (!strcmp(name, "delay")) {
961 len = num_arg(&user_buffer[i], 10, &value);
949 if (len < 0) {
962 if (len < 0)
950 return len;
963 return len;
951 }
964
952 i += len;
953 if (value == 0x7FFFFFFF)
954 pkt_dev->delay = ULLONG_MAX;
955 else
956 pkt_dev->delay = (u64)value * NSEC_PER_USEC;
957
958 sprintf(pg_result, "OK: delay=%llu",
959 (unsigned long long) pkt_dev->delay);
960 return count;
961 }
962 if (!strcmp(name, "udp_src_min")) {
963 len = num_arg(&user_buffer[i], 10, &value);
965 i += len;
966 if (value == 0x7FFFFFFF)
967 pkt_dev->delay = ULLONG_MAX;
968 else
969 pkt_dev->delay = (u64)value * NSEC_PER_USEC;
970
971 sprintf(pg_result, "OK: delay=%llu",
972 (unsigned long long) pkt_dev->delay);
973 return count;
974 }
975 if (!strcmp(name, "udp_src_min")) {
976 len = num_arg(&user_buffer[i], 10, &value);
964 if (len < 0) {
977 if (len < 0)
965 return len;
978 return len;
966 }
979
967 i += len;
968 if (value != pkt_dev->udp_src_min) {
969 pkt_dev->udp_src_min = value;
970 pkt_dev->cur_udp_src = value;
971 }
972 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
973 return count;
974 }
975 if (!strcmp(name, "udp_dst_min")) {
976 len = num_arg(&user_buffer[i], 10, &value);
980 i += len;
981 if (value != pkt_dev->udp_src_min) {
982 pkt_dev->udp_src_min = value;
983 pkt_dev->cur_udp_src = value;
984 }
985 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
986 return count;
987 }
988 if (!strcmp(name, "udp_dst_min")) {
989 len = num_arg(&user_buffer[i], 10, &value);
977 if (len < 0) {
990 if (len < 0)
978 return len;
991 return len;
979 }
992
980 i += len;
981 if (value != pkt_dev->udp_dst_min) {
982 pkt_dev->udp_dst_min = value;
983 pkt_dev->cur_udp_dst = value;
984 }
985 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
986 return count;
987 }
988 if (!strcmp(name, "udp_src_max")) {
989 len = num_arg(&user_buffer[i], 10, &value);
993 i += len;
994 if (value != pkt_dev->udp_dst_min) {
995 pkt_dev->udp_dst_min = value;
996 pkt_dev->cur_udp_dst = value;
997 }
998 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
999 return count;
1000 }
1001 if (!strcmp(name, "udp_src_max")) {
1002 len = num_arg(&user_buffer[i], 10, &value);
990 if (len < 0) {
1003 if (len < 0)
991 return len;
1004 return len;
992 }
1005
993 i += len;
994 if (value != pkt_dev->udp_src_max) {
995 pkt_dev->udp_src_max = value;
996 pkt_dev->cur_udp_src = value;
997 }
998 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
999 return count;
1000 }
1001 if (!strcmp(name, "udp_dst_max")) {
1002 len = num_arg(&user_buffer[i], 10, &value);
1006 i += len;
1007 if (value != pkt_dev->udp_src_max) {
1008 pkt_dev->udp_src_max = value;
1009 pkt_dev->cur_udp_src = value;
1010 }
1011 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
1012 return count;
1013 }
1014 if (!strcmp(name, "udp_dst_max")) {
1015 len = num_arg(&user_buffer[i], 10, &value);
1003 if (len < 0) {
1016 if (len < 0)
1004 return len;
1017 return len;
1005 }
1018
1006 i += len;
1007 if (value != pkt_dev->udp_dst_max) {
1008 pkt_dev->udp_dst_max = value;
1009 pkt_dev->cur_udp_dst = value;
1010 }
1011 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
1012 return count;
1013 }
1014 if (!strcmp(name, "clone_skb")) {
1015 len = num_arg(&user_buffer[i], 10, &value);
1019 i += len;
1020 if (value != pkt_dev->udp_dst_max) {
1021 pkt_dev->udp_dst_max = value;
1022 pkt_dev->cur_udp_dst = value;
1023 }
1024 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
1025 return count;
1026 }
1027 if (!strcmp(name, "clone_skb")) {
1028 len = num_arg(&user_buffer[i], 10, &value);
1016 if (len < 0) {
1029 if (len < 0)
1017 return len;
1030 return len;
1018 }
1031
1019 i += len;
1020 pkt_dev->clone_skb = value;
1021
1022 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
1023 return count;
1024 }
1025 if (!strcmp(name, "count")) {
1026 len = num_arg(&user_buffer[i], 10, &value);
1032 i += len;
1033 pkt_dev->clone_skb = value;
1034
1035 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
1036 return count;
1037 }
1038 if (!strcmp(name, "count")) {
1039 len = num_arg(&user_buffer[i], 10, &value);
1027 if (len < 0) {
1040 if (len < 0)
1028 return len;
1041 return len;
1029 }
1042
1030 i += len;
1031 pkt_dev->count = value;
1032 sprintf(pg_result, "OK: count=%llu",
1033 (unsigned long long)pkt_dev->count);
1034 return count;
1035 }
1036 if (!strcmp(name, "src_mac_count")) {
1037 len = num_arg(&user_buffer[i], 10, &value);
1043 i += len;
1044 pkt_dev->count = value;
1045 sprintf(pg_result, "OK: count=%llu",
1046 (unsigned long long)pkt_dev->count);
1047 return count;
1048 }
1049 if (!strcmp(name, "src_mac_count")) {
1050 len = num_arg(&user_buffer[i], 10, &value);
1038 if (len < 0) {
1051 if (len < 0)
1039 return len;
1052 return len;
1040 }
1053
1041 i += len;
1042 if (pkt_dev->src_mac_count != value) {
1043 pkt_dev->src_mac_count = value;
1044 pkt_dev->cur_src_mac_offset = 0;
1045 }
1046 sprintf(pg_result, "OK: src_mac_count=%d",
1047 pkt_dev->src_mac_count);
1048 return count;
1049 }
1050 if (!strcmp(name, "dst_mac_count")) {
1051 len = num_arg(&user_buffer[i], 10, &value);
1054 i += len;
1055 if (pkt_dev->src_mac_count != value) {
1056 pkt_dev->src_mac_count = value;
1057 pkt_dev->cur_src_mac_offset = 0;
1058 }
1059 sprintf(pg_result, "OK: src_mac_count=%d",
1060 pkt_dev->src_mac_count);
1061 return count;
1062 }
1063 if (!strcmp(name, "dst_mac_count")) {
1064 len = num_arg(&user_buffer[i], 10, &value);
1052 if (len < 0) {
1065 if (len < 0)
1053 return len;
1066 return len;
1054 }
1067
1055 i += len;
1056 if (pkt_dev->dst_mac_count != value) {
1057 pkt_dev->dst_mac_count = value;
1058 pkt_dev->cur_dst_mac_offset = 0;
1059 }
1060 sprintf(pg_result, "OK: dst_mac_count=%d",
1061 pkt_dev->dst_mac_count);
1062 return count;
1063 }
1064 if (!strcmp(name, "flag")) {
1065 char f[32];
1066 memset(f, 0, 32);
1067 len = strn_len(&user_buffer[i], sizeof(f) - 1);
1068 i += len;
1069 if (pkt_dev->dst_mac_count != value) {
1070 pkt_dev->dst_mac_count = value;
1071 pkt_dev->cur_dst_mac_offset = 0;
1072 }
1073 sprintf(pg_result, "OK: dst_mac_count=%d",
1074 pkt_dev->dst_mac_count);
1075 return count;
1076 }
1077 if (!strcmp(name, "flag")) {
1078 char f[32];
1079 memset(f, 0, 32);
1080 len = strn_len(&user_buffer[i], sizeof(f) - 1);
1068 if (len < 0) {
1081 if (len < 0)
1069 return len;
1082 return len;
1070 }
1083
1071 if (copy_from_user(f, &user_buffer[i], len))
1072 return -EFAULT;
1073 i += len;
1074 if (strcmp(f, "IPSRC_RND") == 0)
1075 pkt_dev->flags |= F_IPSRC_RND;
1076
1077 else if (strcmp(f, "!IPSRC_RND") == 0)
1078 pkt_dev->flags &= ~F_IPSRC_RND;

--- 82 unchanged lines hidden (view full) ---

1161 "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, IPSEC\n");
1162 return count;
1163 }
1164 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
1165 return count;
1166 }
1167 if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) {
1168 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_min) - 1);
1084 if (copy_from_user(f, &user_buffer[i], len))
1085 return -EFAULT;
1086 i += len;
1087 if (strcmp(f, "IPSRC_RND") == 0)
1088 pkt_dev->flags |= F_IPSRC_RND;
1089
1090 else if (strcmp(f, "!IPSRC_RND") == 0)
1091 pkt_dev->flags &= ~F_IPSRC_RND;

--- 82 unchanged lines hidden (view full) ---

1174 "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, IPSEC\n");
1175 return count;
1176 }
1177 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
1178 return count;
1179 }
1180 if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) {
1181 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_min) - 1);
1169 if (len < 0) {
1182 if (len < 0)
1170 return len;
1183 return len;
1171 }
1172
1173 if (copy_from_user(buf, &user_buffer[i], len))
1174 return -EFAULT;
1175 buf[len] = 0;
1176 if (strcmp(buf, pkt_dev->dst_min) != 0) {
1177 memset(pkt_dev->dst_min, 0, sizeof(pkt_dev->dst_min));
1178 strncpy(pkt_dev->dst_min, buf, len);
1179 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
1180 pkt_dev->cur_daddr = pkt_dev->daddr_min;
1181 }
1182 if (debug)
1183 printk(KERN_DEBUG "pktgen: dst_min set to: %s\n",
1184 pkt_dev->dst_min);
1185 i += len;
1186 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
1187 return count;
1188 }
1189 if (!strcmp(name, "dst_max")) {
1190 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_max) - 1);
1184
1185 if (copy_from_user(buf, &user_buffer[i], len))
1186 return -EFAULT;
1187 buf[len] = 0;
1188 if (strcmp(buf, pkt_dev->dst_min) != 0) {
1189 memset(pkt_dev->dst_min, 0, sizeof(pkt_dev->dst_min));
1190 strncpy(pkt_dev->dst_min, buf, len);
1191 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
1192 pkt_dev->cur_daddr = pkt_dev->daddr_min;
1193 }
1194 if (debug)
1195 printk(KERN_DEBUG "pktgen: dst_min set to: %s\n",
1196 pkt_dev->dst_min);
1197 i += len;
1198 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
1199 return count;
1200 }
1201 if (!strcmp(name, "dst_max")) {
1202 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_max) - 1);
1191 if (len < 0) {
1203 if (len < 0)
1192 return len;
1204 return len;
1193 }
1194
1205
1206
1195 if (copy_from_user(buf, &user_buffer[i], len))
1196 return -EFAULT;
1197
1198 buf[len] = 0;
1199 if (strcmp(buf, pkt_dev->dst_max) != 0) {
1200 memset(pkt_dev->dst_max, 0, sizeof(pkt_dev->dst_max));
1201 strncpy(pkt_dev->dst_max, buf, len);
1202 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);

--- 93 unchanged lines hidden (view full) ---

1296 printk(KERN_DEBUG "pktgen: src6 set to: %s\n", buf);
1297
1298 i += len;
1299 sprintf(pg_result, "OK: src6=%s", buf);
1300 return count;
1301 }
1302 if (!strcmp(name, "src_min")) {
1303 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_min) - 1);
1207 if (copy_from_user(buf, &user_buffer[i], len))
1208 return -EFAULT;
1209
1210 buf[len] = 0;
1211 if (strcmp(buf, pkt_dev->dst_max) != 0) {
1212 memset(pkt_dev->dst_max, 0, sizeof(pkt_dev->dst_max));
1213 strncpy(pkt_dev->dst_max, buf, len);
1214 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);

--- 93 unchanged lines hidden (view full) ---

1308 printk(KERN_DEBUG "pktgen: src6 set to: %s\n", buf);
1309
1310 i += len;
1311 sprintf(pg_result, "OK: src6=%s", buf);
1312 return count;
1313 }
1314 if (!strcmp(name, "src_min")) {
1315 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_min) - 1);
1304 if (len < 0) {
1316 if (len < 0)
1305 return len;
1317 return len;
1306 }
1318
1307 if (copy_from_user(buf, &user_buffer[i], len))
1308 return -EFAULT;
1309 buf[len] = 0;
1310 if (strcmp(buf, pkt_dev->src_min) != 0) {
1311 memset(pkt_dev->src_min, 0, sizeof(pkt_dev->src_min));
1312 strncpy(pkt_dev->src_min, buf, len);
1313 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
1314 pkt_dev->cur_saddr = pkt_dev->saddr_min;
1315 }
1316 if (debug)
1317 printk(KERN_DEBUG "pktgen: src_min set to: %s\n",
1318 pkt_dev->src_min);
1319 i += len;
1320 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
1321 return count;
1322 }
1323 if (!strcmp(name, "src_max")) {
1324 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_max) - 1);
1319 if (copy_from_user(buf, &user_buffer[i], len))
1320 return -EFAULT;
1321 buf[len] = 0;
1322 if (strcmp(buf, pkt_dev->src_min) != 0) {
1323 memset(pkt_dev->src_min, 0, sizeof(pkt_dev->src_min));
1324 strncpy(pkt_dev->src_min, buf, len);
1325 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
1326 pkt_dev->cur_saddr = pkt_dev->saddr_min;
1327 }
1328 if (debug)
1329 printk(KERN_DEBUG "pktgen: src_min set to: %s\n",
1330 pkt_dev->src_min);
1331 i += len;
1332 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
1333 return count;
1334 }
1335 if (!strcmp(name, "src_max")) {
1336 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_max) - 1);
1325 if (len < 0) {
1337 if (len < 0)
1326 return len;
1338 return len;
1327 }
1339
1328 if (copy_from_user(buf, &user_buffer[i], len))
1329 return -EFAULT;
1330 buf[len] = 0;
1331 if (strcmp(buf, pkt_dev->src_max) != 0) {
1332 memset(pkt_dev->src_max, 0, sizeof(pkt_dev->src_max));
1333 strncpy(pkt_dev->src_max, buf, len);
1334 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
1335 pkt_dev->cur_saddr = pkt_dev->saddr_max;

--- 7 unchanged lines hidden (view full) ---

1343 }
1344 if (!strcmp(name, "dst_mac")) {
1345 char *v = valstr;
1346 unsigned char old_dmac[ETH_ALEN];
1347 unsigned char *m = pkt_dev->dst_mac;
1348 memcpy(old_dmac, pkt_dev->dst_mac, ETH_ALEN);
1349
1350 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1340 if (copy_from_user(buf, &user_buffer[i], len))
1341 return -EFAULT;
1342 buf[len] = 0;
1343 if (strcmp(buf, pkt_dev->src_max) != 0) {
1344 memset(pkt_dev->src_max, 0, sizeof(pkt_dev->src_max));
1345 strncpy(pkt_dev->src_max, buf, len);
1346 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
1347 pkt_dev->cur_saddr = pkt_dev->saddr_max;

--- 7 unchanged lines hidden (view full) ---

1355 }
1356 if (!strcmp(name, "dst_mac")) {
1357 char *v = valstr;
1358 unsigned char old_dmac[ETH_ALEN];
1359 unsigned char *m = pkt_dev->dst_mac;
1360 memcpy(old_dmac, pkt_dev->dst_mac, ETH_ALEN);
1361
1362 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1351 if (len < 0) {
1363 if (len < 0)
1352 return len;
1364 return len;
1353 }
1365
1354 memset(valstr, 0, sizeof(valstr));
1355 if (copy_from_user(valstr, &user_buffer[i], len))
1356 return -EFAULT;
1357 i += len;
1358
1359 for (*m = 0; *v && m < pkt_dev->dst_mac + 6; v++) {
1360 if (*v >= '0' && *v <= '9') {
1361 *m *= 16;

--- 23 unchanged lines hidden (view full) ---

1385 if (!strcmp(name, "src_mac")) {
1386 char *v = valstr;
1387 unsigned char old_smac[ETH_ALEN];
1388 unsigned char *m = pkt_dev->src_mac;
1389
1390 memcpy(old_smac, pkt_dev->src_mac, ETH_ALEN);
1391
1392 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1366 memset(valstr, 0, sizeof(valstr));
1367 if (copy_from_user(valstr, &user_buffer[i], len))
1368 return -EFAULT;
1369 i += len;
1370
1371 for (*m = 0; *v && m < pkt_dev->dst_mac + 6; v++) {
1372 if (*v >= '0' && *v <= '9') {
1373 *m *= 16;

--- 23 unchanged lines hidden (view full) ---

1397 if (!strcmp(name, "src_mac")) {
1398 char *v = valstr;
1399 unsigned char old_smac[ETH_ALEN];
1400 unsigned char *m = pkt_dev->src_mac;
1401
1402 memcpy(old_smac, pkt_dev->src_mac, ETH_ALEN);
1403
1404 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1393 if (len < 0) {
1405 if (len < 0)
1394 return len;
1406 return len;
1395 }
1407
1396 memset(valstr, 0, sizeof(valstr));
1397 if (copy_from_user(valstr, &user_buffer[i], len))
1398 return -EFAULT;
1399 i += len;
1400
1401 for (*m = 0; *v && m < pkt_dev->src_mac + 6; v++) {
1402 if (*v >= '0' && *v <= '9') {
1403 *m *= 16;

--- 24 unchanged lines hidden (view full) ---

1428 if (!strcmp(name, "clear_counters")) {
1429 pktgen_clear_counters(pkt_dev);
1430 sprintf(pg_result, "OK: Clearing counters.\n");
1431 return count;
1432 }
1433
1434 if (!strcmp(name, "flows")) {
1435 len = num_arg(&user_buffer[i], 10, &value);
1408 memset(valstr, 0, sizeof(valstr));
1409 if (copy_from_user(valstr, &user_buffer[i], len))
1410 return -EFAULT;
1411 i += len;
1412
1413 for (*m = 0; *v && m < pkt_dev->src_mac + 6; v++) {
1414 if (*v >= '0' && *v <= '9') {
1415 *m *= 16;

--- 24 unchanged lines hidden (view full) ---

1440 if (!strcmp(name, "clear_counters")) {
1441 pktgen_clear_counters(pkt_dev);
1442 sprintf(pg_result, "OK: Clearing counters.\n");
1443 return count;
1444 }
1445
1446 if (!strcmp(name, "flows")) {
1447 len = num_arg(&user_buffer[i], 10, &value);
1436 if (len < 0) {
1448 if (len < 0)
1437 return len;
1449 return len;
1438 }
1450
1439 i += len;
1440 if (value > MAX_CFLOWS)
1441 value = MAX_CFLOWS;
1442
1443 pkt_dev->cflows = value;
1444 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
1445 return count;
1446 }
1447
1448 if (!strcmp(name, "flowlen")) {
1449 len = num_arg(&user_buffer[i], 10, &value);
1451 i += len;
1452 if (value > MAX_CFLOWS)
1453 value = MAX_CFLOWS;
1454
1455 pkt_dev->cflows = value;
1456 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
1457 return count;
1458 }
1459
1460 if (!strcmp(name, "flowlen")) {
1461 len = num_arg(&user_buffer[i], 10, &value);
1450 if (len < 0) {
1462 if (len < 0)
1451 return len;
1463 return len;
1452 }
1464
1453 i += len;
1454 pkt_dev->lflow = value;
1455 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow);
1456 return count;
1457 }
1458
1459 if (!strcmp(name, "queue_map_min")) {
1460 len = num_arg(&user_buffer[i], 5, &value);
1465 i += len;
1466 pkt_dev->lflow = value;
1467 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow);
1468 return count;
1469 }
1470
1471 if (!strcmp(name, "queue_map_min")) {
1472 len = num_arg(&user_buffer[i], 5, &value);
1461 if (len < 0) {
1473 if (len < 0)
1462 return len;
1474 return len;
1463 }
1475
1464 i += len;
1465 pkt_dev->queue_map_min = value;
1466 sprintf(pg_result, "OK: queue_map_min=%u", pkt_dev->queue_map_min);
1467 return count;
1468 }
1469
1470 if (!strcmp(name, "queue_map_max")) {
1471 len = num_arg(&user_buffer[i], 5, &value);
1476 i += len;
1477 pkt_dev->queue_map_min = value;
1478 sprintf(pg_result, "OK: queue_map_min=%u", pkt_dev->queue_map_min);
1479 return count;
1480 }
1481
1482 if (!strcmp(name, "queue_map_max")) {
1483 len = num_arg(&user_buffer[i], 5, &value);
1472 if (len < 0) {
1484 if (len < 0)
1473 return len;
1485 return len;
1474 }
1486
1475 i += len;
1476 pkt_dev->queue_map_max = value;
1477 sprintf(pg_result, "OK: queue_map_max=%u", pkt_dev->queue_map_max);
1478 return count;
1479 }
1480
1481 if (!strcmp(name, "mpls")) {
1482 unsigned n, cnt;

--- 15 unchanged lines hidden (view full) ---

1498 if (debug)
1499 printk(KERN_DEBUG "pktgen: VLAN/SVLAN auto turned off\n");
1500 }
1501 return count;
1502 }
1503
1504 if (!strcmp(name, "vlan_id")) {
1505 len = num_arg(&user_buffer[i], 4, &value);
1487 i += len;
1488 pkt_dev->queue_map_max = value;
1489 sprintf(pg_result, "OK: queue_map_max=%u", pkt_dev->queue_map_max);
1490 return count;
1491 }
1492
1493 if (!strcmp(name, "mpls")) {
1494 unsigned n, cnt;

--- 15 unchanged lines hidden (view full) ---

1510 if (debug)
1511 printk(KERN_DEBUG "pktgen: VLAN/SVLAN auto turned off\n");
1512 }
1513 return count;
1514 }
1515
1516 if (!strcmp(name, "vlan_id")) {
1517 len = num_arg(&user_buffer[i], 4, &value);
1506 if (len < 0) {
1518 if (len < 0)
1507 return len;
1519 return len;
1508 }
1520
1509 i += len;
1510 if (value <= 4095) {
1511 pkt_dev->vlan_id = value; /* turn on VLAN */
1512
1513 if (debug)
1514 printk(KERN_DEBUG "pktgen: VLAN turned on\n");
1515
1516 if (debug && pkt_dev->nr_labels)

--- 8 unchanged lines hidden (view full) ---

1525 if (debug)
1526 printk(KERN_DEBUG "pktgen: VLAN/SVLAN turned off\n");
1527 }
1528 return count;
1529 }
1530
1531 if (!strcmp(name, "vlan_p")) {
1532 len = num_arg(&user_buffer[i], 1, &value);
1521 i += len;
1522 if (value <= 4095) {
1523 pkt_dev->vlan_id = value; /* turn on VLAN */
1524
1525 if (debug)
1526 printk(KERN_DEBUG "pktgen: VLAN turned on\n");
1527
1528 if (debug && pkt_dev->nr_labels)

--- 8 unchanged lines hidden (view full) ---

1537 if (debug)
1538 printk(KERN_DEBUG "pktgen: VLAN/SVLAN turned off\n");
1539 }
1540 return count;
1541 }
1542
1543 if (!strcmp(name, "vlan_p")) {
1544 len = num_arg(&user_buffer[i], 1, &value);
1533 if (len < 0) {
1545 if (len < 0)
1534 return len;
1546 return len;
1535 }
1547
1536 i += len;
1537 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
1538 pkt_dev->vlan_p = value;
1539 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
1540 } else {
1541 sprintf(pg_result, "ERROR: vlan_p must be 0-7");
1542 }
1543 return count;
1544 }
1545
1546 if (!strcmp(name, "vlan_cfi")) {
1547 len = num_arg(&user_buffer[i], 1, &value);
1548 i += len;
1549 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
1550 pkt_dev->vlan_p = value;
1551 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
1552 } else {
1553 sprintf(pg_result, "ERROR: vlan_p must be 0-7");
1554 }
1555 return count;
1556 }
1557
1558 if (!strcmp(name, "vlan_cfi")) {
1559 len = num_arg(&user_buffer[i], 1, &value);
1548 if (len < 0) {
1560 if (len < 0)
1549 return len;
1561 return len;
1550 }
1562
1551 i += len;
1552 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
1553 pkt_dev->vlan_cfi = value;
1554 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
1555 } else {
1556 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
1557 }
1558 return count;
1559 }
1560
1561 if (!strcmp(name, "svlan_id")) {
1562 len = num_arg(&user_buffer[i], 4, &value);
1563 i += len;
1564 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
1565 pkt_dev->vlan_cfi = value;
1566 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
1567 } else {
1568 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
1569 }
1570 return count;
1571 }
1572
1573 if (!strcmp(name, "svlan_id")) {
1574 len = num_arg(&user_buffer[i], 4, &value);
1563 if (len < 0) {
1575 if (len < 0)
1564 return len;
1576 return len;
1565 }
1577
1566 i += len;
1567 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
1568 pkt_dev->svlan_id = value; /* turn on SVLAN */
1569
1570 if (debug)
1571 printk(KERN_DEBUG "pktgen: SVLAN turned on\n");
1572
1573 if (debug && pkt_dev->nr_labels)

--- 8 unchanged lines hidden (view full) ---

1582 if (debug)
1583 printk(KERN_DEBUG "pktgen: VLAN/SVLAN turned off\n");
1584 }
1585 return count;
1586 }
1587
1588 if (!strcmp(name, "svlan_p")) {
1589 len = num_arg(&user_buffer[i], 1, &value);
1578 i += len;
1579 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
1580 pkt_dev->svlan_id = value; /* turn on SVLAN */
1581
1582 if (debug)
1583 printk(KERN_DEBUG "pktgen: SVLAN turned on\n");
1584
1585 if (debug && pkt_dev->nr_labels)

--- 8 unchanged lines hidden (view full) ---

1594 if (debug)
1595 printk(KERN_DEBUG "pktgen: VLAN/SVLAN turned off\n");
1596 }
1597 return count;
1598 }
1599
1600 if (!strcmp(name, "svlan_p")) {
1601 len = num_arg(&user_buffer[i], 1, &value);
1590 if (len < 0) {
1602 if (len < 0)
1591 return len;
1603 return len;
1592 }
1604
1593 i += len;
1594 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
1595 pkt_dev->svlan_p = value;
1596 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
1597 } else {
1598 sprintf(pg_result, "ERROR: svlan_p must be 0-7");
1599 }
1600 return count;
1601 }
1602
1603 if (!strcmp(name, "svlan_cfi")) {
1604 len = num_arg(&user_buffer[i], 1, &value);
1605 i += len;
1606 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
1607 pkt_dev->svlan_p = value;
1608 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
1609 } else {
1610 sprintf(pg_result, "ERROR: svlan_p must be 0-7");
1611 }
1612 return count;
1613 }
1614
1615 if (!strcmp(name, "svlan_cfi")) {
1616 len = num_arg(&user_buffer[i], 1, &value);
1605 if (len < 0) {
1617 if (len < 0)
1606 return len;
1618 return len;
1607 }
1619
1608 i += len;
1609 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
1610 pkt_dev->svlan_cfi = value;
1611 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
1612 } else {
1613 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
1614 }
1615 return count;
1616 }
1617
1618 if (!strcmp(name, "tos")) {
1619 __u32 tmp_value = 0;
1620 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1620 i += len;
1621 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
1622 pkt_dev->svlan_cfi = value;
1623 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
1624 } else {
1625 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
1626 }
1627 return count;
1628 }
1629
1630 if (!strcmp(name, "tos")) {
1631 __u32 tmp_value = 0;
1632 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1621 if (len < 0) {
1633 if (len < 0)
1622 return len;
1634 return len;
1623 }
1635
1624 i += len;
1625 if (len == 2) {
1626 pkt_dev->tos = tmp_value;
1627 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
1628 } else {
1629 sprintf(pg_result, "ERROR: tos must be 00-ff");
1630 }
1631 return count;
1632 }
1633
1634 if (!strcmp(name, "traffic_class")) {
1635 __u32 tmp_value = 0;
1636 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1636 i += len;
1637 if (len == 2) {
1638 pkt_dev->tos = tmp_value;
1639 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
1640 } else {
1641 sprintf(pg_result, "ERROR: tos must be 00-ff");
1642 }
1643 return count;
1644 }
1645
1646 if (!strcmp(name, "traffic_class")) {
1647 __u32 tmp_value = 0;
1648 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1637 if (len < 0) {
1649 if (len < 0)
1638 return len;
1650 return len;
1639 }
1651
1640 i += len;
1641 if (len == 2) {
1642 pkt_dev->traffic_class = tmp_value;
1643 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
1644 } else {
1645 sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
1646 }
1647 return count;

--- 253 unchanged lines hidden (view full) ---

1901 case NETDEV_UNREGISTER:
1902 pktgen_mark_device(dev->name);
1903 break;
1904 }
1905
1906 return NOTIFY_DONE;
1907}
1908
1652 i += len;
1653 if (len == 2) {
1654 pkt_dev->traffic_class = tmp_value;
1655 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
1656 } else {
1657 sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
1658 }
1659 return count;

--- 253 unchanged lines hidden (view full) ---

1913 case NETDEV_UNREGISTER:
1914 pktgen_mark_device(dev->name);
1915 break;
1916 }
1917
1918 return NOTIFY_DONE;
1919}
1920
1909static struct net_device *pktgen_dev_get_by_name(struct pktgen_dev *pkt_dev, const char *ifname)
1921static struct net_device *pktgen_dev_get_by_name(struct pktgen_dev *pkt_dev,
1922 const char *ifname)
1910{
1911 char b[IFNAMSIZ+5];
1912 int i = 0;
1913
1923{
1924 char b[IFNAMSIZ+5];
1925 int i = 0;
1926
1914 for(i=0; ifname[i] != '@'; i++) {
1915 if(i == IFNAMSIZ)
1927 for (i = 0; ifname[i] != '@'; i++) {
1928 if (i == IFNAMSIZ)
1916 break;
1917
1918 b[i] = ifname[i];
1919 }
1920 b[i] = 0;
1921
1922 return dev_get_by_name(&init_net, b);
1923}

--- 50 unchanged lines hidden (view full) ---

1974
1975 /* make sure that we don't pick a non-existing transmit queue */
1976 ntxq = pkt_dev->odev->real_num_tx_queues;
1977
1978 if (ntxq <= pkt_dev->queue_map_min) {
1979 printk(KERN_WARNING "pktgen: WARNING: Requested "
1980 "queue_map_min (zero-based) (%d) exceeds valid range "
1981 "[0 - %d] for (%d) queues on %s, resetting\n",
1929 break;
1930
1931 b[i] = ifname[i];
1932 }
1933 b[i] = 0;
1934
1935 return dev_get_by_name(&init_net, b);
1936}

--- 50 unchanged lines hidden (view full) ---

1987
1988 /* make sure that we don't pick a non-existing transmit queue */
1989 ntxq = pkt_dev->odev->real_num_tx_queues;
1990
1991 if (ntxq <= pkt_dev->queue_map_min) {
1992 printk(KERN_WARNING "pktgen: WARNING: Requested "
1993 "queue_map_min (zero-based) (%d) exceeds valid range "
1994 "[0 - %d] for (%d) queues on %s, resetting\n",
1982 pkt_dev->queue_map_min, (ntxq ?: 1)- 1, ntxq,
1995 pkt_dev->queue_map_min, (ntxq ?: 1) - 1, ntxq,
1983 pkt_dev->odev->name);
1984 pkt_dev->queue_map_min = ntxq - 1;
1985 }
1986 if (pkt_dev->queue_map_max >= ntxq) {
1987 printk(KERN_WARNING "pktgen: WARNING: Requested "
1988 "queue_map_max (zero-based) (%d) exceeds valid range "
1989 "[0 - %d] for (%d) queues on %s, resetting\n",
1996 pkt_dev->odev->name);
1997 pkt_dev->queue_map_min = ntxq - 1;
1998 }
1999 if (pkt_dev->queue_map_max >= ntxq) {
2000 printk(KERN_WARNING "pktgen: WARNING: Requested "
2001 "queue_map_max (zero-based) (%d) exceeds valid range "
2002 "[0 - %d] for (%d) queues on %s, resetting\n",
1990 pkt_dev->queue_map_max, (ntxq ?: 1)- 1, ntxq,
2003 pkt_dev->queue_map_max, (ntxq ?: 1) - 1, ntxq,
1991 pkt_dev->odev->name);
1992 pkt_dev->queue_map_max = ntxq - 1;
1993 }
1994
1995 /* Default to the interface's mac if not explicitly set. */
1996
1997 if (is_zero_ether_addr(pkt_dev->src_mac))
1998 memcpy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr, ETH_ALEN);

--- 24 unchanged lines hidden (view full) ---

2023
2024 /*
2025 * Use linklevel address if unconfigured.
2026 *
2027 * use ipv6_get_lladdr if/when it's get exported
2028 */
2029
2030 rcu_read_lock();
2004 pkt_dev->odev->name);
2005 pkt_dev->queue_map_max = ntxq - 1;
2006 }
2007
2008 /* Default to the interface's mac if not explicitly set. */
2009
2010 if (is_zero_ether_addr(pkt_dev->src_mac))
2011 memcpy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr, ETH_ALEN);

--- 24 unchanged lines hidden (view full) ---

2036
2037 /*
2038 * Use linklevel address if unconfigured.
2039 *
2040 * use ipv6_get_lladdr if/when it's get exported
2041 */
2042
2043 rcu_read_lock();
2031 if ((idev = __in6_dev_get(pkt_dev->odev)) != NULL) {
2044 idev = __in6_dev_get(pkt_dev->odev);
2045 if (idev) {
2032 struct inet6_ifaddr *ifp;
2033
2034 read_lock_bh(&idev->lock);
2035 for (ifp = idev->addr_list; ifp;
2036 ifp = ifp->if_next) {
2037 if (ifp->scope == IFA_LINK
2038 && !(ifp->
2039 flags & IFA_F_TENTATIVE)) {

--- 136 unchanged lines hidden (view full) ---

2176 (xfrm_address_t *)&pkt_dev->cur_daddr,
2177 (xfrm_address_t *)&pkt_dev->cur_saddr,
2178 AF_INET,
2179 pkt_dev->ipsmode,
2180 pkt_dev->ipsproto, 0);
2181 if (x) {
2182 pkt_dev->flows[flow].x = x;
2183 set_pkt_overhead(pkt_dev);
2046 struct inet6_ifaddr *ifp;
2047
2048 read_lock_bh(&idev->lock);
2049 for (ifp = idev->addr_list; ifp;
2050 ifp = ifp->if_next) {
2051 if (ifp->scope == IFA_LINK
2052 && !(ifp->
2053 flags & IFA_F_TENTATIVE)) {

--- 136 unchanged lines hidden (view full) ---

2190 (xfrm_address_t *)&pkt_dev->cur_daddr,
2191 (xfrm_address_t *)&pkt_dev->cur_saddr,
2192 AF_INET,
2193 pkt_dev->ipsmode,
2194 pkt_dev->ipsproto, 0);
2195 if (x) {
2196 pkt_dev->flows[flow].x = x;
2197 set_pkt_overhead(pkt_dev);
2184 pkt_dev->pkt_overhead+=x->props.header_len;
2198 pkt_dev->pkt_overhead += x->props.header_len;
2185 }
2186
2187 }
2188}
2189#endif
2190static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
2191{
2192

--- 122 unchanged lines hidden (view full) ---

2315 pkt_dev->cur_udp_dst++;
2316 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2317 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2318 }
2319 }
2320
2321 if (!(pkt_dev->flags & F_IPV6)) {
2322
2199 }
2200
2201 }
2202}
2203#endif
2204static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
2205{
2206

--- 122 unchanged lines hidden (view full) ---

2329 pkt_dev->cur_udp_dst++;
2330 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2331 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2332 }
2333 }
2334
2335 if (!(pkt_dev->flags & F_IPV6)) {
2336
2323 if ((imn = ntohl(pkt_dev->saddr_min)) < (imx =
2324 ntohl(pkt_dev->
2325 saddr_max))) {
2337 imn = ntohl(pkt_dev->saddr_min);
2338 imx = ntohl(pkt_dev->saddr_max);
2339 if (imn < imx) {
2326 __u32 t;
2327 if (pkt_dev->flags & F_IPSRC_RND)
2328 t = random32() % (imx - imn) + imn;
2329 else {
2330 t = ntohl(pkt_dev->cur_saddr);
2331 t++;
2340 __u32 t;
2341 if (pkt_dev->flags & F_IPSRC_RND)
2342 t = random32() % (imx - imn) + imn;
2343 else {
2344 t = ntohl(pkt_dev->cur_saddr);
2345 t++;
2332 if (t > imx) {
2346 if (t > imx)
2333 t = imn;
2347 t = imn;
2334 }
2348
2335 }
2336 pkt_dev->cur_saddr = htonl(t);
2337 }
2338
2339 if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2340 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2341 } else {
2342 imn = ntohl(pkt_dev->daddr_min);

--- 94 unchanged lines hidden (view full) ---

2437
2438 err = x->outer_mode->output(x, skb);
2439 if (err)
2440 goto error;
2441 err = x->type->output(x, skb);
2442 if (err)
2443 goto error;
2444
2349 }
2350 pkt_dev->cur_saddr = htonl(t);
2351 }
2352
2353 if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2354 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2355 } else {
2356 imn = ntohl(pkt_dev->daddr_min);

--- 94 unchanged lines hidden (view full) ---

2451
2452 err = x->outer_mode->output(x, skb);
2453 if (err)
2454 goto error;
2455 err = x->type->output(x, skb);
2456 if (err)
2457 goto error;
2458
2445 x->curlft.bytes +=skb->len;
2459 x->curlft.bytes += skb->len;
2446 x->curlft.packets++;
2447error:
2448 spin_unlock(&x->lock);
2449 return err;
2450}
2451
2452static void free_SAs(struct pktgen_dev *pkt_dev)
2453{

--- 15 unchanged lines hidden (view full) ---

2469{
2470 if (pkt_dev->flags & F_IPSEC_ON) {
2471 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2472 int nhead = 0;
2473 if (x) {
2474 int ret;
2475 __u8 *eth;
2476 nhead = x->props.header_len - skb_headroom(skb);
2460 x->curlft.packets++;
2461error:
2462 spin_unlock(&x->lock);
2463 return err;
2464}
2465
2466static void free_SAs(struct pktgen_dev *pkt_dev)
2467{

--- 15 unchanged lines hidden (view full) ---

2483{
2484 if (pkt_dev->flags & F_IPSEC_ON) {
2485 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2486 int nhead = 0;
2487 if (x) {
2488 int ret;
2489 __u8 *eth;
2490 nhead = x->props.header_len - skb_headroom(skb);
2477 if (nhead >0) {
2491 if (nhead > 0) {
2478 ret = pskb_expand_head(skb, nhead, 0, GFP_ATOMIC);
2479 if (ret < 0) {
2480 printk(KERN_ERR "Error expanding "
2492 ret = pskb_expand_head(skb, nhead, 0, GFP_ATOMIC);
2493 if (ret < 0) {
2494 printk(KERN_ERR "Error expanding "
2481 "ipsec packet %d\n",ret);
2495 "ipsec packet %d\n", ret);
2482 goto err;
2483 }
2484 }
2485
2486 /* ipsec is not expecting ll header */
2487 skb_pull(skb, ETH_HLEN);
2488 ret = pktgen_output_ipsec(skb, pkt_dev);
2489 if (ret) {
2490 printk(KERN_ERR "Error creating ipsec "
2496 goto err;
2497 }
2498 }
2499
2500 /* ipsec is not expecting ll header */
2501 skb_pull(skb, ETH_HLEN);
2502 ret = pktgen_output_ipsec(skb, pkt_dev);
2503 if (ret) {
2504 printk(KERN_ERR "Error creating ipsec "
2491 "packet %d\n",ret);
2505 "packet %d\n", ret);
2492 goto err;
2493 }
2494 /* restore ll */
2495 eth = (__u8 *) skb_push(skb, ETH_HLEN);
2496 memcpy(eth, pkt_dev->hh, 12);
2506 goto err;
2507 }
2508 /* restore ll */
2509 eth = (__u8 *) skb_push(skb, ETH_HLEN);
2510 memcpy(eth, pkt_dev->hh, 12);
2497 *(u16 *) & eth[12] = protocol;
2511 *(u16 *) &eth[12] = protocol;
2498 }
2499 }
2500 return 1;
2501err:
2502 kfree_skb(skb);
2503 return 0;
2504}
2505#endif
2506
2507static void mpls_push(__be32 *mpls, struct pktgen_dev *pkt_dev)
2508{
2509 unsigned i;
2512 }
2513 }
2514 return 1;
2515err:
2516 kfree_skb(skb);
2517 return 0;
2518}
2519#endif
2520
2521static void mpls_push(__be32 *mpls, struct pktgen_dev *pkt_dev)
2522{
2523 unsigned i;
2510 for (i = 0; i < pkt_dev->nr_labels; i++) {
2524 for (i = 0; i < pkt_dev->nr_labels; i++)
2511 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2525 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2512 }
2526
2513 mpls--;
2514 *mpls |= MPLS_STACK_BOTTOM;
2515}
2516
2517static inline __be16 build_tci(unsigned int id, unsigned int cfi,
2518 unsigned int prio)
2519{
2520 return htons(id | (cfi << 12) | (prio << 13));

--- 150 unchanged lines hidden (view full) ---

2671 skb_shinfo(skb)->frags[i].page_offset +=
2672 skb_shinfo(skb)->frags[i - 1].size;
2673 skb_shinfo(skb)->frags[i].size = rem;
2674 i++;
2675 skb_shinfo(skb)->nr_frags = i;
2676 }
2677 }
2678
2527 mpls--;
2528 *mpls |= MPLS_STACK_BOTTOM;
2529}
2530
2531static inline __be16 build_tci(unsigned int id, unsigned int cfi,
2532 unsigned int prio)
2533{
2534 return htons(id | (cfi << 12) | (prio << 13));

--- 150 unchanged lines hidden (view full) ---

2685 skb_shinfo(skb)->frags[i].page_offset +=
2686 skb_shinfo(skb)->frags[i - 1].size;
2687 skb_shinfo(skb)->frags[i].size = rem;
2688 i++;
2689 skb_shinfo(skb)->nr_frags = i;
2690 }
2691 }
2692
2679 /* Stamp the time, and sequence number, convert them to network byte order */
2680
2693 /* Stamp the time, and sequence number,
2694 * convert them to network byte order
2695 */
2681 if (pgh) {
2682 struct timeval timestamp;
2683
2684 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2685 pgh->seq_num = htonl(pkt_dev->seq_num);
2686
2687 do_gettimeofday(&timestamp);
2688 pgh->tv_sec = htonl(timestamp.tv_sec);

--- 237 unchanged lines hidden (view full) ---

2926 skb->network_header = skb->tail;
2927 skb->transport_header = skb->network_header + sizeof(struct ipv6hdr);
2928 skb_put(skb, sizeof(struct ipv6hdr) + sizeof(struct udphdr));
2929 skb_set_queue_mapping(skb, queue_map);
2930 iph = ipv6_hdr(skb);
2931 udph = udp_hdr(skb);
2932
2933 memcpy(eth, pkt_dev->hh, 12);
2696 if (pgh) {
2697 struct timeval timestamp;
2698
2699 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2700 pgh->seq_num = htonl(pkt_dev->seq_num);
2701
2702 do_gettimeofday(&timestamp);
2703 pgh->tv_sec = htonl(timestamp.tv_sec);

--- 237 unchanged lines hidden (view full) ---

2941 skb->network_header = skb->tail;
2942 skb->transport_header = skb->network_header + sizeof(struct ipv6hdr);
2943 skb_put(skb, sizeof(struct ipv6hdr) + sizeof(struct udphdr));
2944 skb_set_queue_mapping(skb, queue_map);
2945 iph = ipv6_hdr(skb);
2946 udph = udp_hdr(skb);
2947
2948 memcpy(eth, pkt_dev->hh, 12);
2934 *(__be16 *) & eth[12] = protocol;
2949 *(__be16 *) &eth[12] = protocol;
2935
2936 /* Eth + IPh + UDPh + mpls */
2937 datalen = pkt_dev->cur_pkt_size - 14 -
2938 sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
2939 pkt_dev->pkt_overhead;
2940
2941 if (datalen < sizeof(struct pktgen_hdr)) {
2942 datalen = sizeof(struct pktgen_hdr);

--- 77 unchanged lines hidden (view full) ---

3020 skb_shinfo(skb)->frags[i].page_offset +=
3021 skb_shinfo(skb)->frags[i - 1].size;
3022 skb_shinfo(skb)->frags[i].size = rem;
3023 i++;
3024 skb_shinfo(skb)->nr_frags = i;
3025 }
3026 }
3027
2950
2951 /* Eth + IPh + UDPh + mpls */
2952 datalen = pkt_dev->cur_pkt_size - 14 -
2953 sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
2954 pkt_dev->pkt_overhead;
2955
2956 if (datalen < sizeof(struct pktgen_hdr)) {
2957 datalen = sizeof(struct pktgen_hdr);

--- 77 unchanged lines hidden (view full) ---

3035 skb_shinfo(skb)->frags[i].page_offset +=
3036 skb_shinfo(skb)->frags[i - 1].size;
3037 skb_shinfo(skb)->frags[i].size = rem;
3038 i++;
3039 skb_shinfo(skb)->nr_frags = i;
3040 }
3041 }
3042
3028 /* Stamp the time, and sequence number, convert them to network byte order */
3029 /* should we update cloned packets too ? */
3043 /* Stamp the time, and sequence number,
3044 * convert them to network byte order
3045 * should we update cloned packets too ?
3046 */
3030 if (pgh) {
3031 struct timeval timestamp;
3032
3033 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
3034 pgh->seq_num = htonl(pkt_dev->seq_num);
3035
3036 do_gettimeofday(&timestamp);
3037 pgh->tv_sec = htonl(timestamp.tv_sec);

--- 131 unchanged lines hidden (view full) ---

3169
3170 mutex_lock(&pktgen_thread_lock);
3171
3172 list_for_each_entry(t, &pktgen_threads, th_list)
3173 t->control |= (T_RUN);
3174
3175 mutex_unlock(&pktgen_thread_lock);
3176
3047 if (pgh) {
3048 struct timeval timestamp;
3049
3050 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
3051 pgh->seq_num = htonl(pkt_dev->seq_num);
3052
3053 do_gettimeofday(&timestamp);
3054 pgh->tv_sec = htonl(timestamp.tv_sec);

--- 131 unchanged lines hidden (view full) ---

3186
3187 mutex_lock(&pktgen_thread_lock);
3188
3189 list_for_each_entry(t, &pktgen_threads, th_list)
3190 t->control |= (T_RUN);
3191
3192 mutex_unlock(&pktgen_thread_lock);
3193
3177 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
3194 /* Propagate thread->control */
3195 schedule_timeout_interruptible(msecs_to_jiffies(125));
3178
3179 pktgen_wait_all_threads_run();
3180}
3181
3182static void pktgen_reset_all_threads(void)
3183{
3184 struct pktgen_thread *t;
3185
3186 pr_debug("pktgen: entering pktgen_reset_all_threads.\n");
3187
3188 mutex_lock(&pktgen_thread_lock);
3189
3190 list_for_each_entry(t, &pktgen_threads, th_list)
3191 t->control |= (T_REMDEVALL);
3192
3193 mutex_unlock(&pktgen_thread_lock);
3194
3196
3197 pktgen_wait_all_threads_run();
3198}
3199
3200static void pktgen_reset_all_threads(void)
3201{
3202 struct pktgen_thread *t;
3203
3204 pr_debug("pktgen: entering pktgen_reset_all_threads.\n");
3205
3206 mutex_lock(&pktgen_thread_lock);
3207
3208 list_for_each_entry(t, &pktgen_threads, th_list)
3209 t->control |= (T_REMDEVALL);
3210
3211 mutex_unlock(&pktgen_thread_lock);
3212
3195 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
3213 /* Propagate thread->control */
3214 schedule_timeout_interruptible(msecs_to_jiffies(125));
3196
3197 pktgen_wait_all_threads_run();
3198}
3199
3200static void show_results(struct pktgen_dev *pkt_dev, int nr_frags)
3201{
3202 __u64 bps, mbps, pps;
3203 char *p = pkt_dev->result;

--- 276 unchanged lines hidden (view full) ---

3480 struct pktgen_dev *pkt_dev = NULL;
3481 int cpu = t->cpu;
3482
3483 BUG_ON(smp_processor_id() != cpu);
3484
3485 init_waitqueue_head(&t->queue);
3486 complete(&t->start_done);
3487
3215
3216 pktgen_wait_all_threads_run();
3217}
3218
3219static void show_results(struct pktgen_dev *pkt_dev, int nr_frags)
3220{
3221 __u64 bps, mbps, pps;
3222 char *p = pkt_dev->result;

--- 276 unchanged lines hidden (view full) ---

3499 struct pktgen_dev *pkt_dev = NULL;
3500 int cpu = t->cpu;
3501
3502 BUG_ON(smp_processor_id() != cpu);
3503
3504 init_waitqueue_head(&t->queue);
3505 complete(&t->start_done);
3506
3488 pr_debug("pktgen: starting pktgen/%d: pid=%d\n", cpu, task_pid_nr(current));
3507 pr_debug("pktgen: starting pktgen/%d: pid=%d\n",
3508 cpu, task_pid_nr(current));
3489
3490 set_current_state(TASK_INTERRUPTIBLE);
3491
3492 set_freezable();
3493
3494 while (!kthread_should_stop()) {
3495 pkt_dev = next_to_run(t);
3496

--- 345 unchanged lines hidden --- 		3509
3510 set_current_state(TASK_INTERRUPTIBLE);
3511
3512 set_freezable();
3513
3514 while (!kthread_should_stop()) {
3515 pkt_dev = next_to_run(t);
3516

--- 345 unchanged lines hidden ---