1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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/mutex.h>
121#include <linux/sched.h>
122#include <linux/slab.h>
123#include <linux/vmalloc.h>
124#include <linux/unistd.h>
125#include <linux/string.h>
126#include <linux/ptrace.h>
127#include <linux/errno.h>
128#include <linux/ioport.h>
129#include <linux/interrupt.h>
130#include <linux/capability.h>
131#include <linux/hrtimer.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 <linux/prefetch.h>
154#include <linux/mmzone.h>
155#include <net/net_namespace.h>
156#include <net/checksum.h>
157#include <net/ipv6.h>
158#include <net/udp.h>
159#include <net/ip6_checksum.h>
160#include <net/addrconf.h>
161#ifdef CONFIG_XFRM
162#include <net/xfrm.h>
163#endif
164#include <net/netns/generic.h>
165#include <asm/byteorder.h>
166#include <linux/rcupdate.h>
167#include <linux/bitops.h>
168#include <linux/io.h>
169#include <linux/timex.h>
170#include <linux/uaccess.h>
171#include <asm/dma.h>
172#include <asm/div64.h>
173
174#define VERSION "2.75"
175#define IP_NAME_SZ 32
176#define MAX_MPLS_LABELS 16
177#define MPLS_STACK_BOTTOM htonl(0x00000100)
178
179#define func_enter() pr_debug("entering %s\n", __func__);
180
181#define PKT_FLAGS \
182 pf(IPV6) \
183 pf(IPSRC_RND) \
184 pf(IPDST_RND) \
185 pf(TXSIZE_RND) \
186 pf(UDPSRC_RND) \
187 pf(UDPDST_RND) \
188 pf(UDPCSUM) \
189 pf(NO_TIMESTAMP) \
190 pf(MPLS_RND) \
191 pf(QUEUE_MAP_RND) \
192 pf(QUEUE_MAP_CPU) \
193 pf(FLOW_SEQ) \
194 pf(IPSEC) \
195 pf(MACSRC_RND) \
196 pf(MACDST_RND) \
197 pf(VID_RND) \
198 pf(SVID_RND) \
199 pf(NODE) \
200
201#define pf(flag) flag##_SHIFT,
202enum pkt_flags {
203 PKT_FLAGS
204};
205#undef pf
206
207
208#define pf(flag) static const __u32 F_##flag = (1<<flag##_SHIFT);
209PKT_FLAGS
210#undef pf
211
212#define pf(flag) __stringify(flag),
213static char *pkt_flag_names[] = {
214 PKT_FLAGS
215};
216#undef pf
217
218#define NR_PKT_FLAGS ARRAY_SIZE(pkt_flag_names)
219
220
221#define T_STOP (1<<0)
222#define T_RUN (1<<1)
223#define T_REMDEVALL (1<<2)
224#define T_REMDEV (1<<3)
225
226
227#define M_START_XMIT 0
228#define M_NETIF_RECEIVE 1
229#define M_QUEUE_XMIT 2
230
231
232#define if_lock(t) mutex_lock(&(t->if_lock));
233#define if_unlock(t) mutex_unlock(&(t->if_lock));
234
235
236#define PKTGEN_MAGIC 0xbe9be955
237#define PG_PROC_DIR "pktgen"
238#define PGCTRL "pgctrl"
239
240#define MAX_CFLOWS 65536
241
242#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)
243#define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)
244
245struct flow_state {
246 __be32 cur_daddr;
247 int count;
248#ifdef CONFIG_XFRM
249 struct xfrm_state *x;
250#endif
251 __u32 flags;
252};
253
254
255#define F_INIT (1<<0)
256
257struct pktgen_dev {
258
259
260
261 struct proc_dir_entry *entry;
262 struct pktgen_thread *pg_thread;
263 struct list_head list;
264 struct rcu_head rcu;
265
266 int running;
267
268
269
270
271 __u32 flags;
272 int xmit_mode;
273 int min_pkt_size;
274 int max_pkt_size;
275 int pkt_overhead;
276 int nfrags;
277 int removal_mark;
278
279
280 struct page *page;
281 u64 delay;
282
283 __u64 count;
284 __u64 sofar;
285 __u64 tx_bytes;
286 __u64 errors;
287
288
289
290 __u32 clone_count;
291 int last_ok;
292
293
294
295 ktime_t next_tx;
296 ktime_t started_at;
297 ktime_t stopped_at;
298 u64 idle_acc;
299
300 __u32 seq_num;
301
302 int clone_skb;
303
304
305
306
307
308
309
310
311
312 char dst_min[IP_NAME_SZ];
313 char dst_max[IP_NAME_SZ];
314 char src_min[IP_NAME_SZ];
315 char src_max[IP_NAME_SZ];
316
317 struct in6_addr in6_saddr;
318 struct in6_addr in6_daddr;
319 struct in6_addr cur_in6_daddr;
320 struct in6_addr cur_in6_saddr;
321
322 struct in6_addr min_in6_daddr;
323 struct in6_addr max_in6_daddr;
324 struct in6_addr min_in6_saddr;
325 struct in6_addr max_in6_saddr;
326
327
328
329
330 __be32 saddr_min;
331 __be32 saddr_max;
332 __be32 daddr_min;
333 __be32 daddr_max;
334
335 __u16 udp_src_min;
336 __u16 udp_src_max;
337 __u16 udp_dst_min;
338 __u16 udp_dst_max;
339
340
341 __u8 tos;
342
343 __u8 traffic_class;
344
345
346
347 unsigned int nr_labels;
348 __be32 labels[MAX_MPLS_LABELS];
349
350
351 __u8 vlan_p;
352 __u8 vlan_cfi;
353 __u16 vlan_id;
354
355 __u8 svlan_p;
356 __u8 svlan_cfi;
357 __u16 svlan_id;
358
359 __u32 src_mac_count;
360 __u32 dst_mac_count;
361
362 unsigned char dst_mac[ETH_ALEN];
363 unsigned char src_mac[ETH_ALEN];
364
365 __u32 cur_dst_mac_offset;
366 __u32 cur_src_mac_offset;
367 __be32 cur_saddr;
368 __be32 cur_daddr;
369 __u16 ip_id;
370 __u16 cur_udp_dst;
371 __u16 cur_udp_src;
372 __u16 cur_queue_map;
373 __u32 cur_pkt_size;
374 __u32 last_pkt_size;
375
376 __u8 hh[14];
377
378
379
380
381
382
383
384
385 __u16 pad;
386
387 struct sk_buff *skb;
388
389
390 struct net_device *odev;
391
392
393
394
395
396
397
398 char odevname[32];
399 struct flow_state *flows;
400 unsigned int cflows;
401 unsigned int lflow;
402 unsigned int nflows;
403 unsigned int curfl;
404
405 u16 queue_map_min;
406 u16 queue_map_max;
407 __u32 skb_priority;
408 unsigned int burst;
409 int node;
410
411#ifdef CONFIG_XFRM
412 __u8 ipsmode;
413 __u8 ipsproto;
414 __u32 spi;
415 struct xfrm_dst xdst;
416 struct dst_ops dstops;
417#endif
418 char result[512];
419};
420
421struct pktgen_hdr {
422 __be32 pgh_magic;
423 __be32 seq_num;
424 __be32 tv_sec;
425 __be32 tv_usec;
426};
427
428
429static unsigned int pg_net_id __read_mostly;
430
431struct pktgen_net {
432 struct net *net;
433 struct proc_dir_entry *proc_dir;
434 struct list_head pktgen_threads;
435 bool pktgen_exiting;
436};
437
438struct pktgen_thread {
439 struct mutex if_lock;
440 struct list_head if_list;
441 struct list_head th_list;
442 struct task_struct *tsk;
443 char result[512];
444
445
446
447
448 u32 control;
449 int cpu;
450
451 wait_queue_head_t queue;
452 struct completion start_done;
453 struct pktgen_net *net;
454};
455
456#define REMOVE 1
457#define FIND 0
458
459static const char version[] =
460 "Packet Generator for packet performance testing. "
461 "Version: " VERSION "\n";
462
463static int pktgen_remove_device(struct pktgen_thread *t, struct pktgen_dev *i);
464static int pktgen_add_device(struct pktgen_thread *t, const char *ifname);
465static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t,
466 const char *ifname, bool exact);
467static int pktgen_device_event(struct notifier_block *, unsigned long, void *);
468static void pktgen_run_all_threads(struct pktgen_net *pn);
469static void pktgen_reset_all_threads(struct pktgen_net *pn);
470static void pktgen_stop_all_threads_ifs(struct pktgen_net *pn);
471
472static void pktgen_stop(struct pktgen_thread *t);
473static void pktgen_clear_counters(struct pktgen_dev *pkt_dev);
474
475
476static int pg_count_d __read_mostly = 1000;
477static int pg_delay_d __read_mostly;
478static int pg_clone_skb_d __read_mostly;
479static int debug __read_mostly;
480
481static DEFINE_MUTEX(pktgen_thread_lock);
482
483static struct notifier_block pktgen_notifier_block = {
484 .notifier_call = pktgen_device_event,
485};
486
487
488
489
490
491
492static int pgctrl_show(struct seq_file *seq, void *v)
493{
494 seq_puts(seq, version);
495 return 0;
496}
497
498static ssize_t pgctrl_write(struct file *file, const char __user *buf,
499 size_t count, loff_t *ppos)
500{
501 char data[128];
502 struct pktgen_net *pn = net_generic(current->nsproxy->net_ns, pg_net_id);
503
504 if (!capable(CAP_NET_ADMIN))
505 return -EPERM;
506
507 if (count == 0)
508 return -EINVAL;
509
510 if (count > sizeof(data))
511 count = sizeof(data);
512
513 if (copy_from_user(data, buf, count))
514 return -EFAULT;
515
516 data[count - 1] = 0;
517
518 if (!strcmp(data, "stop"))
519 pktgen_stop_all_threads_ifs(pn);
520
521 else if (!strcmp(data, "start"))
522 pktgen_run_all_threads(pn);
523
524 else if (!strcmp(data, "reset"))
525 pktgen_reset_all_threads(pn);
526
527 else
528 return -EINVAL;
529
530 return count;
531}
532
533static int pgctrl_open(struct inode *inode, struct file *file)
534{
535 return single_open(file, pgctrl_show, PDE_DATA(inode));
536}
537
538static const struct file_operations pktgen_fops = {
539 .open = pgctrl_open,
540 .read = seq_read,
541 .llseek = seq_lseek,
542 .write = pgctrl_write,
543 .release = single_release,
544};
545
546static int pktgen_if_show(struct seq_file *seq, void *v)
547{
548 const struct pktgen_dev *pkt_dev = seq->private;
549 ktime_t stopped;
550 unsigned int i;
551 u64 idle;
552
553 seq_printf(seq,
554 "Params: count %llu min_pkt_size: %u max_pkt_size: %u\n",
555 (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size,
556 pkt_dev->max_pkt_size);
557
558 seq_printf(seq,
559 " frags: %d delay: %llu clone_skb: %d ifname: %s\n",
560 pkt_dev->nfrags, (unsigned long long) pkt_dev->delay,
561 pkt_dev->clone_skb, pkt_dev->odevname);
562
563 seq_printf(seq, " flows: %u flowlen: %u\n", pkt_dev->cflows,
564 pkt_dev->lflow);
565
566 seq_printf(seq,
567 " queue_map_min: %u queue_map_max: %u\n",
568 pkt_dev->queue_map_min,
569 pkt_dev->queue_map_max);
570
571 if (pkt_dev->skb_priority)
572 seq_printf(seq, " skb_priority: %u\n",
573 pkt_dev->skb_priority);
574
575 if (pkt_dev->flags & F_IPV6) {
576 seq_printf(seq,
577 " saddr: %pI6c min_saddr: %pI6c max_saddr: %pI6c\n"
578 " daddr: %pI6c min_daddr: %pI6c max_daddr: %pI6c\n",
579 &pkt_dev->in6_saddr,
580 &pkt_dev->min_in6_saddr, &pkt_dev->max_in6_saddr,
581 &pkt_dev->in6_daddr,
582 &pkt_dev->min_in6_daddr, &pkt_dev->max_in6_daddr);
583 } else {
584 seq_printf(seq,
585 " dst_min: %s dst_max: %s\n",
586 pkt_dev->dst_min, pkt_dev->dst_max);
587 seq_printf(seq,
588 " src_min: %s src_max: %s\n",
589 pkt_dev->src_min, pkt_dev->src_max);
590 }
591
592 seq_puts(seq, " src_mac: ");
593
594 seq_printf(seq, "%pM ",
595 is_zero_ether_addr(pkt_dev->src_mac) ?
596 pkt_dev->odev->dev_addr : pkt_dev->src_mac);
597
598 seq_puts(seq, "dst_mac: ");
599 seq_printf(seq, "%pM\n", pkt_dev->dst_mac);
600
601 seq_printf(seq,
602 " udp_src_min: %d udp_src_max: %d"
603 " udp_dst_min: %d udp_dst_max: %d\n",
604 pkt_dev->udp_src_min, pkt_dev->udp_src_max,
605 pkt_dev->udp_dst_min, pkt_dev->udp_dst_max);
606
607 seq_printf(seq,
608 " src_mac_count: %d dst_mac_count: %d\n",
609 pkt_dev->src_mac_count, pkt_dev->dst_mac_count);
610
611 if (pkt_dev->nr_labels) {
612 seq_puts(seq, " mpls: ");
613 for (i = 0; i < pkt_dev->nr_labels; i++)
614 seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]),
615 i == pkt_dev->nr_labels-1 ? "\n" : ", ");
616 }
617
618 if (pkt_dev->vlan_id != 0xffff)
619 seq_printf(seq, " vlan_id: %u vlan_p: %u vlan_cfi: %u\n",
620 pkt_dev->vlan_id, pkt_dev->vlan_p,
621 pkt_dev->vlan_cfi);
622
623 if (pkt_dev->svlan_id != 0xffff)
624 seq_printf(seq, " svlan_id: %u vlan_p: %u vlan_cfi: %u\n",
625 pkt_dev->svlan_id, pkt_dev->svlan_p,
626 pkt_dev->svlan_cfi);
627
628 if (pkt_dev->tos)
629 seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos);
630
631 if (pkt_dev->traffic_class)
632 seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class);
633
634 if (pkt_dev->burst > 1)
635 seq_printf(seq, " burst: %d\n", pkt_dev->burst);
636
637 if (pkt_dev->node >= 0)
638 seq_printf(seq, " node: %d\n", pkt_dev->node);
639
640 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE)
641 seq_puts(seq, " xmit_mode: netif_receive\n");
642 else if (pkt_dev->xmit_mode == M_QUEUE_XMIT)
643 seq_puts(seq, " xmit_mode: xmit_queue\n");
644
645 seq_puts(seq, " Flags: ");
646
647 for (i = 0; i < NR_PKT_FLAGS; i++) {
648 if (i == F_FLOW_SEQ)
649 if (!pkt_dev->cflows)
650 continue;
651
652 if (pkt_dev->flags & (1 << i))
653 seq_printf(seq, "%s ", pkt_flag_names[i]);
654 else if (i == F_FLOW_SEQ)
655 seq_puts(seq, "FLOW_RND ");
656
657#ifdef CONFIG_XFRM
658 if (i == F_IPSEC && pkt_dev->spi)
659 seq_printf(seq, "spi:%u", pkt_dev->spi);
660#endif
661 }
662
663 seq_puts(seq, "\n");
664
665
666 stopped = pkt_dev->running ? ktime_get() : pkt_dev->stopped_at;
667 idle = pkt_dev->idle_acc;
668 do_div(idle, NSEC_PER_USEC);
669
670 seq_printf(seq,
671 "Current:\n pkts-sofar: %llu errors: %llu\n",
672 (unsigned long long)pkt_dev->sofar,
673 (unsigned long long)pkt_dev->errors);
674
675 seq_printf(seq,
676 " started: %lluus stopped: %lluus idle: %lluus\n",
677 (unsigned long long) ktime_to_us(pkt_dev->started_at),
678 (unsigned long long) ktime_to_us(stopped),
679 (unsigned long long) idle);
680
681 seq_printf(seq,
682 " seq_num: %d cur_dst_mac_offset: %d cur_src_mac_offset: %d\n",
683 pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset,
684 pkt_dev->cur_src_mac_offset);
685
686 if (pkt_dev->flags & F_IPV6) {
687 seq_printf(seq, " cur_saddr: %pI6c cur_daddr: %pI6c\n",
688 &pkt_dev->cur_in6_saddr,
689 &pkt_dev->cur_in6_daddr);
690 } else
691 seq_printf(seq, " cur_saddr: %pI4 cur_daddr: %pI4\n",
692 &pkt_dev->cur_saddr, &pkt_dev->cur_daddr);
693
694 seq_printf(seq, " cur_udp_dst: %d cur_udp_src: %d\n",
695 pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src);
696
697 seq_printf(seq, " cur_queue_map: %u\n", pkt_dev->cur_queue_map);
698
699 seq_printf(seq, " flows: %u\n", pkt_dev->nflows);
700
701 if (pkt_dev->result[0])
702 seq_printf(seq, "Result: %s\n", pkt_dev->result);
703 else
704 seq_puts(seq, "Result: Idle\n");
705
706 return 0;
707}
708
709
710static int hex32_arg(const char __user *user_buffer, unsigned long maxlen,
711 __u32 *num)
712{
713 int i = 0;
714 *num = 0;
715
716 for (; i < maxlen; i++) {
717 int value;
718 char c;
719 *num <<= 4;
720 if (get_user(c, &user_buffer[i]))
721 return -EFAULT;
722 value = hex_to_bin(c);
723 if (value >= 0)
724 *num |= value;
725 else
726 break;
727 }
728 return i;
729}
730
731static int count_trail_chars(const char __user * user_buffer,
732 unsigned int maxlen)
733{
734 int i;
735
736 for (i = 0; i < maxlen; i++) {
737 char c;
738 if (get_user(c, &user_buffer[i]))
739 return -EFAULT;
740 switch (c) {
741 case '\"':
742 case '\n':
743 case '\r':
744 case '\t':
745 case ' ':
746 case '=':
747 break;
748 default:
749 goto done;
750 }
751 }
752done:
753 return i;
754}
755
756static long num_arg(const char __user *user_buffer, unsigned long maxlen,
757 unsigned long *num)
758{
759 int i;
760 *num = 0;
761
762 for (i = 0; i < maxlen; i++) {
763 char c;
764 if (get_user(c, &user_buffer[i]))
765 return -EFAULT;
766 if ((c >= '0') && (c <= '9')) {
767 *num *= 10;
768 *num += c - '0';
769 } else
770 break;
771 }
772 return i;
773}
774
775static int strn_len(const char __user * user_buffer, unsigned int maxlen)
776{
777 int i;
778
779 for (i = 0; i < maxlen; i++) {
780 char c;
781 if (get_user(c, &user_buffer[i]))
782 return -EFAULT;
783 switch (c) {
784 case '\"':
785 case '\n':
786 case '\r':
787 case '\t':
788 case ' ':
789 goto done_str;
790 default:
791 break;
792 }
793 }
794done_str:
795 return i;
796}
797
798static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev)
799{
800 unsigned int n = 0;
801 char c;
802 ssize_t i = 0;
803 int len;
804
805 pkt_dev->nr_labels = 0;
806 do {
807 __u32 tmp;
808 len = hex32_arg(&buffer[i], 8, &tmp);
809 if (len <= 0)
810 return len;
811 pkt_dev->labels[n] = htonl(tmp);
812 if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM)
813 pkt_dev->flags |= F_MPLS_RND;
814 i += len;
815 if (get_user(c, &buffer[i]))
816 return -EFAULT;
817 i++;
818 n++;
819 if (n >= MAX_MPLS_LABELS)
820 return -E2BIG;
821 } while (c == ',');
822
823 pkt_dev->nr_labels = n;
824 return i;
825}
826
827static __u32 pktgen_read_flag(const char *f, bool *disable)
828{
829 __u32 i;
830
831 if (f[0] == '!') {
832 *disable = true;
833 f++;
834 }
835
836 for (i = 0; i < NR_PKT_FLAGS; i++) {
837 if (!IS_ENABLED(CONFIG_XFRM) && i == IPSEC_SHIFT)
838 continue;
839
840
841 if (!*disable && i == IPV6_SHIFT)
842 continue;
843
844 if (strcmp(f, pkt_flag_names[i]) == 0)
845 return 1 << i;
846 }
847
848 if (strcmp(f, "FLOW_RND") == 0) {
849 *disable = !*disable;
850 return F_FLOW_SEQ;
851 }
852
853 return 0;
854}
855
856static ssize_t pktgen_if_write(struct file *file,
857 const char __user * user_buffer, size_t count,
858 loff_t * offset)
859{
860 struct seq_file *seq = file->private_data;
861 struct pktgen_dev *pkt_dev = seq->private;
862 int i, max, len;
863 char name[16], valstr[32];
864 unsigned long value = 0;
865 char *pg_result = NULL;
866 int tmp = 0;
867 char buf[128];
868
869 pg_result = &(pkt_dev->result[0]);
870
871 if (count < 1) {
872 pr_warn("wrong command format\n");
873 return -EINVAL;
874 }
875
876 max = count;
877 tmp = count_trail_chars(user_buffer, max);
878 if (tmp < 0) {
879 pr_warn("illegal format\n");
880 return tmp;
881 }
882 i = tmp;
883
884
885
886 len = strn_len(&user_buffer[i], sizeof(name) - 1);
887 if (len < 0)
888 return len;
889
890 memset(name, 0, sizeof(name));
891 if (copy_from_user(name, &user_buffer[i], len))
892 return -EFAULT;
893 i += len;
894
895 max = count - i;
896 len = count_trail_chars(&user_buffer[i], max);
897 if (len < 0)
898 return len;
899
900 i += len;
901
902 if (debug) {
903 size_t copy = min_t(size_t, count + 1, 1024);
904 char *tp = strndup_user(user_buffer, copy);
905
906 if (IS_ERR(tp))
907 return PTR_ERR(tp);
908
909 pr_debug("%s,%zu buffer -:%s:-\n", name, count, tp);
910 kfree(tp);
911 }
912
913 if (!strcmp(name, "min_pkt_size")) {
914 len = num_arg(&user_buffer[i], 10, &value);
915 if (len < 0)
916 return len;
917
918 i += len;
919 if (value < 14 + 20 + 8)
920 value = 14 + 20 + 8;
921 if (value != pkt_dev->min_pkt_size) {
922 pkt_dev->min_pkt_size = value;
923 pkt_dev->cur_pkt_size = value;
924 }
925 sprintf(pg_result, "OK: min_pkt_size=%u",
926 pkt_dev->min_pkt_size);
927 return count;
928 }
929
930 if (!strcmp(name, "max_pkt_size")) {
931 len = num_arg(&user_buffer[i], 10, &value);
932 if (len < 0)
933 return len;
934
935 i += len;
936 if (value < 14 + 20 + 8)
937 value = 14 + 20 + 8;
938 if (value != pkt_dev->max_pkt_size) {
939 pkt_dev->max_pkt_size = value;
940 pkt_dev->cur_pkt_size = value;
941 }
942 sprintf(pg_result, "OK: max_pkt_size=%u",
943 pkt_dev->max_pkt_size);
944 return count;
945 }
946
947
948
949 if (!strcmp(name, "pkt_size")) {
950 len = num_arg(&user_buffer[i], 10, &value);
951 if (len < 0)
952 return len;
953
954 i += len;
955 if (value < 14 + 20 + 8)
956 value = 14 + 20 + 8;
957 if (value != pkt_dev->min_pkt_size) {
958 pkt_dev->min_pkt_size = value;
959 pkt_dev->max_pkt_size = value;
960 pkt_dev->cur_pkt_size = value;
961 }
962 sprintf(pg_result, "OK: pkt_size=%u", pkt_dev->min_pkt_size);
963 return count;
964 }
965
966 if (!strcmp(name, "debug")) {
967 len = num_arg(&user_buffer[i], 10, &value);
968 if (len < 0)
969 return len;
970
971 i += len;
972 debug = value;
973 sprintf(pg_result, "OK: debug=%u", debug);
974 return count;
975 }
976
977 if (!strcmp(name, "frags")) {
978 len = num_arg(&user_buffer[i], 10, &value);
979 if (len < 0)
980 return len;
981
982 i += len;
983 pkt_dev->nfrags = value;
984 sprintf(pg_result, "OK: frags=%u", pkt_dev->nfrags);
985 return count;
986 }
987 if (!strcmp(name, "delay")) {
988 len = num_arg(&user_buffer[i], 10, &value);
989 if (len < 0)
990 return len;
991
992 i += len;
993 if (value == 0x7FFFFFFF)
994 pkt_dev->delay = ULLONG_MAX;
995 else
996 pkt_dev->delay = (u64)value;
997
998 sprintf(pg_result, "OK: delay=%llu",
999 (unsigned long long) pkt_dev->delay);
1000 return count;
1001 }
1002 if (!strcmp(name, "rate")) {
1003 len = num_arg(&user_buffer[i], 10, &value);
1004 if (len < 0)
1005 return len;
1006
1007 i += len;
1008 if (!value)
1009 return len;
1010 pkt_dev->delay = pkt_dev->min_pkt_size*8*NSEC_PER_USEC/value;
1011 if (debug)
1012 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1013
1014 sprintf(pg_result, "OK: rate=%lu", value);
1015 return count;
1016 }
1017 if (!strcmp(name, "ratep")) {
1018 len = num_arg(&user_buffer[i], 10, &value);
1019 if (len < 0)
1020 return len;
1021
1022 i += len;
1023 if (!value)
1024 return len;
1025 pkt_dev->delay = NSEC_PER_SEC/value;
1026 if (debug)
1027 pr_info("Delay set at: %llu ns\n", pkt_dev->delay);
1028
1029 sprintf(pg_result, "OK: rate=%lu", value);
1030 return count;
1031 }
1032 if (!strcmp(name, "udp_src_min")) {
1033 len = num_arg(&user_buffer[i], 10, &value);
1034 if (len < 0)
1035 return len;
1036
1037 i += len;
1038 if (value != pkt_dev->udp_src_min) {
1039 pkt_dev->udp_src_min = value;
1040 pkt_dev->cur_udp_src = value;
1041 }
1042 sprintf(pg_result, "OK: udp_src_min=%u", pkt_dev->udp_src_min);
1043 return count;
1044 }
1045 if (!strcmp(name, "udp_dst_min")) {
1046 len = num_arg(&user_buffer[i], 10, &value);
1047 if (len < 0)
1048 return len;
1049
1050 i += len;
1051 if (value != pkt_dev->udp_dst_min) {
1052 pkt_dev->udp_dst_min = value;
1053 pkt_dev->cur_udp_dst = value;
1054 }
1055 sprintf(pg_result, "OK: udp_dst_min=%u", pkt_dev->udp_dst_min);
1056 return count;
1057 }
1058 if (!strcmp(name, "udp_src_max")) {
1059 len = num_arg(&user_buffer[i], 10, &value);
1060 if (len < 0)
1061 return len;
1062
1063 i += len;
1064 if (value != pkt_dev->udp_src_max) {
1065 pkt_dev->udp_src_max = value;
1066 pkt_dev->cur_udp_src = value;
1067 }
1068 sprintf(pg_result, "OK: udp_src_max=%u", pkt_dev->udp_src_max);
1069 return count;
1070 }
1071 if (!strcmp(name, "udp_dst_max")) {
1072 len = num_arg(&user_buffer[i], 10, &value);
1073 if (len < 0)
1074 return len;
1075
1076 i += len;
1077 if (value != pkt_dev->udp_dst_max) {
1078 pkt_dev->udp_dst_max = value;
1079 pkt_dev->cur_udp_dst = value;
1080 }
1081 sprintf(pg_result, "OK: udp_dst_max=%u", pkt_dev->udp_dst_max);
1082 return count;
1083 }
1084 if (!strcmp(name, "clone_skb")) {
1085 len = num_arg(&user_buffer[i], 10, &value);
1086 if (len < 0)
1087 return len;
1088 if ((value > 0) &&
1089 ((pkt_dev->xmit_mode == M_NETIF_RECEIVE) ||
1090 !(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))
1091 return -ENOTSUPP;
1092 i += len;
1093 pkt_dev->clone_skb = value;
1094
1095 sprintf(pg_result, "OK: clone_skb=%d", pkt_dev->clone_skb);
1096 return count;
1097 }
1098 if (!strcmp(name, "count")) {
1099 len = num_arg(&user_buffer[i], 10, &value);
1100 if (len < 0)
1101 return len;
1102
1103 i += len;
1104 pkt_dev->count = value;
1105 sprintf(pg_result, "OK: count=%llu",
1106 (unsigned long long)pkt_dev->count);
1107 return count;
1108 }
1109 if (!strcmp(name, "src_mac_count")) {
1110 len = num_arg(&user_buffer[i], 10, &value);
1111 if (len < 0)
1112 return len;
1113
1114 i += len;
1115 if (pkt_dev->src_mac_count != value) {
1116 pkt_dev->src_mac_count = value;
1117 pkt_dev->cur_src_mac_offset = 0;
1118 }
1119 sprintf(pg_result, "OK: src_mac_count=%d",
1120 pkt_dev->src_mac_count);
1121 return count;
1122 }
1123 if (!strcmp(name, "dst_mac_count")) {
1124 len = num_arg(&user_buffer[i], 10, &value);
1125 if (len < 0)
1126 return len;
1127
1128 i += len;
1129 if (pkt_dev->dst_mac_count != value) {
1130 pkt_dev->dst_mac_count = value;
1131 pkt_dev->cur_dst_mac_offset = 0;
1132 }
1133 sprintf(pg_result, "OK: dst_mac_count=%d",
1134 pkt_dev->dst_mac_count);
1135 return count;
1136 }
1137 if (!strcmp(name, "burst")) {
1138 len = num_arg(&user_buffer[i], 10, &value);
1139 if (len < 0)
1140 return len;
1141
1142 i += len;
1143 if ((value > 1) &&
1144 ((pkt_dev->xmit_mode == M_QUEUE_XMIT) ||
1145 ((pkt_dev->xmit_mode == M_START_XMIT) &&
1146 (!(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))))
1147 return -ENOTSUPP;
1148 pkt_dev->burst = value < 1 ? 1 : value;
1149 sprintf(pg_result, "OK: burst=%d", pkt_dev->burst);
1150 return count;
1151 }
1152 if (!strcmp(name, "node")) {
1153 len = num_arg(&user_buffer[i], 10, &value);
1154 if (len < 0)
1155 return len;
1156
1157 i += len;
1158
1159 if (node_possible(value)) {
1160 pkt_dev->node = value;
1161 sprintf(pg_result, "OK: node=%d", pkt_dev->node);
1162 if (pkt_dev->page) {
1163 put_page(pkt_dev->page);
1164 pkt_dev->page = NULL;
1165 }
1166 }
1167 else
1168 sprintf(pg_result, "ERROR: node not possible");
1169 return count;
1170 }
1171 if (!strcmp(name, "xmit_mode")) {
1172 char f[32];
1173
1174 memset(f, 0, 32);
1175 len = strn_len(&user_buffer[i], sizeof(f) - 1);
1176 if (len < 0)
1177 return len;
1178
1179 if (copy_from_user(f, &user_buffer[i], len))
1180 return -EFAULT;
1181 i += len;
1182
1183 if (strcmp(f, "start_xmit") == 0) {
1184 pkt_dev->xmit_mode = M_START_XMIT;
1185 } else if (strcmp(f, "netif_receive") == 0) {
1186
1187 if (pkt_dev->clone_skb > 0)
1188 return -ENOTSUPP;
1189
1190 pkt_dev->xmit_mode = M_NETIF_RECEIVE;
1191
1192
1193
1194
1195 pkt_dev->last_ok = 1;
1196
1197
1198
1199
1200 pkt_dev->clone_skb = 0;
1201 } else if (strcmp(f, "queue_xmit") == 0) {
1202 pkt_dev->xmit_mode = M_QUEUE_XMIT;
1203 pkt_dev->last_ok = 1;
1204 } else {
1205 sprintf(pg_result,
1206 "xmit_mode -:%s:- unknown\nAvailable modes: %s",
1207 f, "start_xmit, netif_receive\n");
1208 return count;
1209 }
1210 sprintf(pg_result, "OK: xmit_mode=%s", f);
1211 return count;
1212 }
1213 if (!strcmp(name, "flag")) {
1214 __u32 flag;
1215 char f[32];
1216 bool disable = false;
1217
1218 memset(f, 0, 32);
1219 len = strn_len(&user_buffer[i], sizeof(f) - 1);
1220 if (len < 0)
1221 return len;
1222
1223 if (copy_from_user(f, &user_buffer[i], len))
1224 return -EFAULT;
1225 i += len;
1226
1227 flag = pktgen_read_flag(f, &disable);
1228
1229 if (flag) {
1230 if (disable)
1231 pkt_dev->flags &= ~flag;
1232 else
1233 pkt_dev->flags |= flag;
1234 } else {
1235 sprintf(pg_result,
1236 "Flag -:%s:- unknown\nAvailable flags, (prepend ! to un-set flag):\n%s",
1237 f,
1238 "IPSRC_RND, IPDST_RND, UDPSRC_RND, UDPDST_RND, "
1239 "MACSRC_RND, MACDST_RND, TXSIZE_RND, IPV6, "
1240 "MPLS_RND, VID_RND, SVID_RND, FLOW_SEQ, "
1241 "QUEUE_MAP_RND, QUEUE_MAP_CPU, UDPCSUM, "
1242 "NO_TIMESTAMP, "
1243#ifdef CONFIG_XFRM
1244 "IPSEC, "
1245#endif
1246 "NODE_ALLOC\n");
1247 return count;
1248 }
1249 sprintf(pg_result, "OK: flags=0x%x", pkt_dev->flags);
1250 return count;
1251 }
1252 if (!strcmp(name, "dst_min") || !strcmp(name, "dst")) {
1253 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_min) - 1);
1254 if (len < 0)
1255 return len;
1256
1257 if (copy_from_user(buf, &user_buffer[i], len))
1258 return -EFAULT;
1259 buf[len] = 0;
1260 if (strcmp(buf, pkt_dev->dst_min) != 0) {
1261 memset(pkt_dev->dst_min, 0, sizeof(pkt_dev->dst_min));
1262 strcpy(pkt_dev->dst_min, buf);
1263 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
1264 pkt_dev->cur_daddr = pkt_dev->daddr_min;
1265 }
1266 if (debug)
1267 pr_debug("dst_min set to: %s\n", pkt_dev->dst_min);
1268 i += len;
1269 sprintf(pg_result, "OK: dst_min=%s", pkt_dev->dst_min);
1270 return count;
1271 }
1272 if (!strcmp(name, "dst_max")) {
1273 len = strn_len(&user_buffer[i], sizeof(pkt_dev->dst_max) - 1);
1274 if (len < 0)
1275 return len;
1276
1277 if (copy_from_user(buf, &user_buffer[i], len))
1278 return -EFAULT;
1279 buf[len] = 0;
1280 if (strcmp(buf, pkt_dev->dst_max) != 0) {
1281 memset(pkt_dev->dst_max, 0, sizeof(pkt_dev->dst_max));
1282 strcpy(pkt_dev->dst_max, buf);
1283 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
1284 pkt_dev->cur_daddr = pkt_dev->daddr_max;
1285 }
1286 if (debug)
1287 pr_debug("dst_max set to: %s\n", pkt_dev->dst_max);
1288 i += len;
1289 sprintf(pg_result, "OK: dst_max=%s", pkt_dev->dst_max);
1290 return count;
1291 }
1292 if (!strcmp(name, "dst6")) {
1293 len = strn_len(&user_buffer[i], sizeof(buf) - 1);
1294 if (len < 0)
1295 return len;
1296
1297 pkt_dev->flags |= F_IPV6;
1298
1299 if (copy_from_user(buf, &user_buffer[i], len))
1300 return -EFAULT;
1301 buf[len] = 0;
1302
1303 in6_pton(buf, -1, pkt_dev->in6_daddr.s6_addr, -1, NULL);
1304 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_daddr);
1305
1306 pkt_dev->cur_in6_daddr = pkt_dev->in6_daddr;
1307
1308 if (debug)
1309 pr_debug("dst6 set to: %s\n", buf);
1310
1311 i += len;
1312 sprintf(pg_result, "OK: dst6=%s", buf);
1313 return count;
1314 }
1315 if (!strcmp(name, "dst6_min")) {
1316 len = strn_len(&user_buffer[i], sizeof(buf) - 1);
1317 if (len < 0)
1318 return len;
1319
1320 pkt_dev->flags |= F_IPV6;
1321
1322 if (copy_from_user(buf, &user_buffer[i], len))
1323 return -EFAULT;
1324 buf[len] = 0;
1325
1326 in6_pton(buf, -1, pkt_dev->min_in6_daddr.s6_addr, -1, NULL);
1327 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->min_in6_daddr);
1328
1329 pkt_dev->cur_in6_daddr = pkt_dev->min_in6_daddr;
1330 if (debug)
1331 pr_debug("dst6_min set to: %s\n", buf);
1332
1333 i += len;
1334 sprintf(pg_result, "OK: dst6_min=%s", buf);
1335 return count;
1336 }
1337 if (!strcmp(name, "dst6_max")) {
1338 len = strn_len(&user_buffer[i], sizeof(buf) - 1);
1339 if (len < 0)
1340 return len;
1341
1342 pkt_dev->flags |= F_IPV6;
1343
1344 if (copy_from_user(buf, &user_buffer[i], len))
1345 return -EFAULT;
1346 buf[len] = 0;
1347
1348 in6_pton(buf, -1, pkt_dev->max_in6_daddr.s6_addr, -1, NULL);
1349 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->max_in6_daddr);
1350
1351 if (debug)
1352 pr_debug("dst6_max set to: %s\n", buf);
1353
1354 i += len;
1355 sprintf(pg_result, "OK: dst6_max=%s", buf);
1356 return count;
1357 }
1358 if (!strcmp(name, "src6")) {
1359 len = strn_len(&user_buffer[i], sizeof(buf) - 1);
1360 if (len < 0)
1361 return len;
1362
1363 pkt_dev->flags |= F_IPV6;
1364
1365 if (copy_from_user(buf, &user_buffer[i], len))
1366 return -EFAULT;
1367 buf[len] = 0;
1368
1369 in6_pton(buf, -1, pkt_dev->in6_saddr.s6_addr, -1, NULL);
1370 snprintf(buf, sizeof(buf), "%pI6c", &pkt_dev->in6_saddr);
1371
1372 pkt_dev->cur_in6_saddr = pkt_dev->in6_saddr;
1373
1374 if (debug)
1375 pr_debug("src6 set to: %s\n", buf);
1376
1377 i += len;
1378 sprintf(pg_result, "OK: src6=%s", buf);
1379 return count;
1380 }
1381 if (!strcmp(name, "src_min")) {
1382 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_min) - 1);
1383 if (len < 0)
1384 return len;
1385
1386 if (copy_from_user(buf, &user_buffer[i], len))
1387 return -EFAULT;
1388 buf[len] = 0;
1389 if (strcmp(buf, pkt_dev->src_min) != 0) {
1390 memset(pkt_dev->src_min, 0, sizeof(pkt_dev->src_min));
1391 strcpy(pkt_dev->src_min, buf);
1392 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
1393 pkt_dev->cur_saddr = pkt_dev->saddr_min;
1394 }
1395 if (debug)
1396 pr_debug("src_min set to: %s\n", pkt_dev->src_min);
1397 i += len;
1398 sprintf(pg_result, "OK: src_min=%s", pkt_dev->src_min);
1399 return count;
1400 }
1401 if (!strcmp(name, "src_max")) {
1402 len = strn_len(&user_buffer[i], sizeof(pkt_dev->src_max) - 1);
1403 if (len < 0)
1404 return len;
1405
1406 if (copy_from_user(buf, &user_buffer[i], len))
1407 return -EFAULT;
1408 buf[len] = 0;
1409 if (strcmp(buf, pkt_dev->src_max) != 0) {
1410 memset(pkt_dev->src_max, 0, sizeof(pkt_dev->src_max));
1411 strcpy(pkt_dev->src_max, buf);
1412 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
1413 pkt_dev->cur_saddr = pkt_dev->saddr_max;
1414 }
1415 if (debug)
1416 pr_debug("src_max set to: %s\n", pkt_dev->src_max);
1417 i += len;
1418 sprintf(pg_result, "OK: src_max=%s", pkt_dev->src_max);
1419 return count;
1420 }
1421 if (!strcmp(name, "dst_mac")) {
1422 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1423 if (len < 0)
1424 return len;
1425
1426 memset(valstr, 0, sizeof(valstr));
1427 if (copy_from_user(valstr, &user_buffer[i], len))
1428 return -EFAULT;
1429
1430 if (!mac_pton(valstr, pkt_dev->dst_mac))
1431 return -EINVAL;
1432
1433 ether_addr_copy(&pkt_dev->hh[0], pkt_dev->dst_mac);
1434
1435 sprintf(pg_result, "OK: dstmac %pM", pkt_dev->dst_mac);
1436 return count;
1437 }
1438 if (!strcmp(name, "src_mac")) {
1439 len = strn_len(&user_buffer[i], sizeof(valstr) - 1);
1440 if (len < 0)
1441 return len;
1442
1443 memset(valstr, 0, sizeof(valstr));
1444 if (copy_from_user(valstr, &user_buffer[i], len))
1445 return -EFAULT;
1446
1447 if (!mac_pton(valstr, pkt_dev->src_mac))
1448 return -EINVAL;
1449
1450 ether_addr_copy(&pkt_dev->hh[6], pkt_dev->src_mac);
1451
1452 sprintf(pg_result, "OK: srcmac %pM", pkt_dev->src_mac);
1453 return count;
1454 }
1455
1456 if (!strcmp(name, "clear_counters")) {
1457 pktgen_clear_counters(pkt_dev);
1458 sprintf(pg_result, "OK: Clearing counters.\n");
1459 return count;
1460 }
1461
1462 if (!strcmp(name, "flows")) {
1463 len = num_arg(&user_buffer[i], 10, &value);
1464 if (len < 0)
1465 return len;
1466
1467 i += len;
1468 if (value > MAX_CFLOWS)
1469 value = MAX_CFLOWS;
1470
1471 pkt_dev->cflows = value;
1472 sprintf(pg_result, "OK: flows=%u", pkt_dev->cflows);
1473 return count;
1474 }
1475#ifdef CONFIG_XFRM
1476 if (!strcmp(name, "spi")) {
1477 len = num_arg(&user_buffer[i], 10, &value);
1478 if (len < 0)
1479 return len;
1480
1481 i += len;
1482 pkt_dev->spi = value;
1483 sprintf(pg_result, "OK: spi=%u", pkt_dev->spi);
1484 return count;
1485 }
1486#endif
1487 if (!strcmp(name, "flowlen")) {
1488 len = num_arg(&user_buffer[i], 10, &value);
1489 if (len < 0)
1490 return len;
1491
1492 i += len;
1493 pkt_dev->lflow = value;
1494 sprintf(pg_result, "OK: flowlen=%u", pkt_dev->lflow);
1495 return count;
1496 }
1497
1498 if (!strcmp(name, "queue_map_min")) {
1499 len = num_arg(&user_buffer[i], 5, &value);
1500 if (len < 0)
1501 return len;
1502
1503 i += len;
1504 pkt_dev->queue_map_min = value;
1505 sprintf(pg_result, "OK: queue_map_min=%u", pkt_dev->queue_map_min);
1506 return count;
1507 }
1508
1509 if (!strcmp(name, "queue_map_max")) {
1510 len = num_arg(&user_buffer[i], 5, &value);
1511 if (len < 0)
1512 return len;
1513
1514 i += len;
1515 pkt_dev->queue_map_max = value;
1516 sprintf(pg_result, "OK: queue_map_max=%u", pkt_dev->queue_map_max);
1517 return count;
1518 }
1519
1520 if (!strcmp(name, "mpls")) {
1521 unsigned int n, cnt;
1522
1523 len = get_labels(&user_buffer[i], pkt_dev);
1524 if (len < 0)
1525 return len;
1526 i += len;
1527 cnt = sprintf(pg_result, "OK: mpls=");
1528 for (n = 0; n < pkt_dev->nr_labels; n++)
1529 cnt += sprintf(pg_result + cnt,
1530 "%08x%s", ntohl(pkt_dev->labels[n]),
1531 n == pkt_dev->nr_labels-1 ? "" : ",");
1532
1533 if (pkt_dev->nr_labels && pkt_dev->vlan_id != 0xffff) {
1534 pkt_dev->vlan_id = 0xffff;
1535 pkt_dev->svlan_id = 0xffff;
1536
1537 if (debug)
1538 pr_debug("VLAN/SVLAN auto turned off\n");
1539 }
1540 return count;
1541 }
1542
1543 if (!strcmp(name, "vlan_id")) {
1544 len = num_arg(&user_buffer[i], 4, &value);
1545 if (len < 0)
1546 return len;
1547
1548 i += len;
1549 if (value <= 4095) {
1550 pkt_dev->vlan_id = value;
1551
1552 if (debug)
1553 pr_debug("VLAN turned on\n");
1554
1555 if (debug && pkt_dev->nr_labels)
1556 pr_debug("MPLS auto turned off\n");
1557
1558 pkt_dev->nr_labels = 0;
1559 sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id);
1560 } else {
1561 pkt_dev->vlan_id = 0xffff;
1562 pkt_dev->svlan_id = 0xffff;
1563
1564 if (debug)
1565 pr_debug("VLAN/SVLAN turned off\n");
1566 }
1567 return count;
1568 }
1569
1570 if (!strcmp(name, "vlan_p")) {
1571 len = num_arg(&user_buffer[i], 1, &value);
1572 if (len < 0)
1573 return len;
1574
1575 i += len;
1576 if ((value <= 7) && (pkt_dev->vlan_id != 0xffff)) {
1577 pkt_dev->vlan_p = value;
1578 sprintf(pg_result, "OK: vlan_p=%u", pkt_dev->vlan_p);
1579 } else {
1580 sprintf(pg_result, "ERROR: vlan_p must be 0-7");
1581 }
1582 return count;
1583 }
1584
1585 if (!strcmp(name, "vlan_cfi")) {
1586 len = num_arg(&user_buffer[i], 1, &value);
1587 if (len < 0)
1588 return len;
1589
1590 i += len;
1591 if ((value <= 1) && (pkt_dev->vlan_id != 0xffff)) {
1592 pkt_dev->vlan_cfi = value;
1593 sprintf(pg_result, "OK: vlan_cfi=%u", pkt_dev->vlan_cfi);
1594 } else {
1595 sprintf(pg_result, "ERROR: vlan_cfi must be 0-1");
1596 }
1597 return count;
1598 }
1599
1600 if (!strcmp(name, "svlan_id")) {
1601 len = num_arg(&user_buffer[i], 4, &value);
1602 if (len < 0)
1603 return len;
1604
1605 i += len;
1606 if ((value <= 4095) && ((pkt_dev->vlan_id != 0xffff))) {
1607 pkt_dev->svlan_id = value;
1608
1609 if (debug)
1610 pr_debug("SVLAN turned on\n");
1611
1612 if (debug && pkt_dev->nr_labels)
1613 pr_debug("MPLS auto turned off\n");
1614
1615 pkt_dev->nr_labels = 0;
1616 sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id);
1617 } else {
1618 pkt_dev->vlan_id = 0xffff;
1619 pkt_dev->svlan_id = 0xffff;
1620
1621 if (debug)
1622 pr_debug("VLAN/SVLAN turned off\n");
1623 }
1624 return count;
1625 }
1626
1627 if (!strcmp(name, "svlan_p")) {
1628 len = num_arg(&user_buffer[i], 1, &value);
1629 if (len < 0)
1630 return len;
1631
1632 i += len;
1633 if ((value <= 7) && (pkt_dev->svlan_id != 0xffff)) {
1634 pkt_dev->svlan_p = value;
1635 sprintf(pg_result, "OK: svlan_p=%u", pkt_dev->svlan_p);
1636 } else {
1637 sprintf(pg_result, "ERROR: svlan_p must be 0-7");
1638 }
1639 return count;
1640 }
1641
1642 if (!strcmp(name, "svlan_cfi")) {
1643 len = num_arg(&user_buffer[i], 1, &value);
1644 if (len < 0)
1645 return len;
1646
1647 i += len;
1648 if ((value <= 1) && (pkt_dev->svlan_id != 0xffff)) {
1649 pkt_dev->svlan_cfi = value;
1650 sprintf(pg_result, "OK: svlan_cfi=%u", pkt_dev->svlan_cfi);
1651 } else {
1652 sprintf(pg_result, "ERROR: svlan_cfi must be 0-1");
1653 }
1654 return count;
1655 }
1656
1657 if (!strcmp(name, "tos")) {
1658 __u32 tmp_value = 0;
1659 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1660 if (len < 0)
1661 return len;
1662
1663 i += len;
1664 if (len == 2) {
1665 pkt_dev->tos = tmp_value;
1666 sprintf(pg_result, "OK: tos=0x%02x", pkt_dev->tos);
1667 } else {
1668 sprintf(pg_result, "ERROR: tos must be 00-ff");
1669 }
1670 return count;
1671 }
1672
1673 if (!strcmp(name, "traffic_class")) {
1674 __u32 tmp_value = 0;
1675 len = hex32_arg(&user_buffer[i], 2, &tmp_value);
1676 if (len < 0)
1677 return len;
1678
1679 i += len;
1680 if (len == 2) {
1681 pkt_dev->traffic_class = tmp_value;
1682 sprintf(pg_result, "OK: traffic_class=0x%02x", pkt_dev->traffic_class);
1683 } else {
1684 sprintf(pg_result, "ERROR: traffic_class must be 00-ff");
1685 }
1686 return count;
1687 }
1688
1689 if (!strcmp(name, "skb_priority")) {
1690 len = num_arg(&user_buffer[i], 9, &value);
1691 if (len < 0)
1692 return len;
1693
1694 i += len;
1695 pkt_dev->skb_priority = value;
1696 sprintf(pg_result, "OK: skb_priority=%i",
1697 pkt_dev->skb_priority);
1698 return count;
1699 }
1700
1701 sprintf(pkt_dev->result, "No such parameter \"%s\"", name);
1702 return -EINVAL;
1703}
1704
1705static int pktgen_if_open(struct inode *inode, struct file *file)
1706{
1707 return single_open(file, pktgen_if_show, PDE_DATA(inode));
1708}
1709
1710static const struct file_operations pktgen_if_fops = {
1711 .open = pktgen_if_open,
1712 .read = seq_read,
1713 .llseek = seq_lseek,
1714 .write = pktgen_if_write,
1715 .release = single_release,
1716};
1717
1718static int pktgen_thread_show(struct seq_file *seq, void *v)
1719{
1720 struct pktgen_thread *t = seq->private;
1721 const struct pktgen_dev *pkt_dev;
1722
1723 BUG_ON(!t);
1724
1725 seq_puts(seq, "Running: ");
1726
1727 rcu_read_lock();
1728 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1729 if (pkt_dev->running)
1730 seq_printf(seq, "%s ", pkt_dev->odevname);
1731
1732 seq_puts(seq, "\nStopped: ");
1733
1734 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
1735 if (!pkt_dev->running)
1736 seq_printf(seq, "%s ", pkt_dev->odevname);
1737
1738 if (t->result[0])
1739 seq_printf(seq, "\nResult: %s\n", t->result);
1740 else
1741 seq_puts(seq, "\nResult: NA\n");
1742
1743 rcu_read_unlock();
1744
1745 return 0;
1746}
1747
1748static ssize_t pktgen_thread_write(struct file *file,
1749 const char __user * user_buffer,
1750 size_t count, loff_t * offset)
1751{
1752 struct seq_file *seq = file->private_data;
1753 struct pktgen_thread *t = seq->private;
1754 int i, max, len, ret;
1755 char name[40];
1756 char *pg_result;
1757
1758 if (count < 1) {
1759
1760 return -EINVAL;
1761 }
1762
1763 max = count;
1764 len = count_trail_chars(user_buffer, max);
1765 if (len < 0)
1766 return len;
1767
1768 i = len;
1769
1770
1771
1772 len = strn_len(&user_buffer[i], sizeof(name) - 1);
1773 if (len < 0)
1774 return len;
1775
1776 memset(name, 0, sizeof(name));
1777 if (copy_from_user(name, &user_buffer[i], len))
1778 return -EFAULT;
1779 i += len;
1780
1781 max = count - i;
1782 len = count_trail_chars(&user_buffer[i], max);
1783 if (len < 0)
1784 return len;
1785
1786 i += len;
1787
1788 if (debug)
1789 pr_debug("t=%s, count=%lu\n", name, (unsigned long)count);
1790
1791 if (!t) {
1792 pr_err("ERROR: No thread\n");
1793 ret = -EINVAL;
1794 goto out;
1795 }
1796
1797 pg_result = &(t->result[0]);
1798
1799 if (!strcmp(name, "add_device")) {
1800 char f[32];
1801 memset(f, 0, 32);
1802 len = strn_len(&user_buffer[i], sizeof(f) - 1);
1803 if (len < 0) {
1804 ret = len;
1805 goto out;
1806 }
1807 if (copy_from_user(f, &user_buffer[i], len))
1808 return -EFAULT;
1809 i += len;
1810 mutex_lock(&pktgen_thread_lock);
1811 ret = pktgen_add_device(t, f);
1812 mutex_unlock(&pktgen_thread_lock);
1813 if (!ret) {
1814 ret = count;
1815 sprintf(pg_result, "OK: add_device=%s", f);
1816 } else
1817 sprintf(pg_result, "ERROR: can not add device %s", f);
1818 goto out;
1819 }
1820
1821 if (!strcmp(name, "rem_device_all")) {
1822 mutex_lock(&pktgen_thread_lock);
1823 t->control |= T_REMDEVALL;
1824 mutex_unlock(&pktgen_thread_lock);
1825 schedule_timeout_interruptible(msecs_to_jiffies(125));
1826 ret = count;
1827 sprintf(pg_result, "OK: rem_device_all");
1828 goto out;
1829 }
1830
1831 if (!strcmp(name, "max_before_softirq")) {
1832 sprintf(pg_result, "OK: Note! max_before_softirq is obsoleted -- Do not use");
1833 ret = count;
1834 goto out;
1835 }
1836
1837 ret = -EINVAL;
1838out:
1839 return ret;
1840}
1841
1842static int pktgen_thread_open(struct inode *inode, struct file *file)
1843{
1844 return single_open(file, pktgen_thread_show, PDE_DATA(inode));
1845}
1846
1847static const struct file_operations pktgen_thread_fops = {
1848 .open = pktgen_thread_open,
1849 .read = seq_read,
1850 .llseek = seq_lseek,
1851 .write = pktgen_thread_write,
1852 .release = single_release,
1853};
1854
1855
1856static struct pktgen_dev *__pktgen_NN_threads(const struct pktgen_net *pn,
1857 const char *ifname, int remove)
1858{
1859 struct pktgen_thread *t;
1860 struct pktgen_dev *pkt_dev = NULL;
1861 bool exact = (remove == FIND);
1862
1863 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
1864 pkt_dev = pktgen_find_dev(t, ifname, exact);
1865 if (pkt_dev) {
1866 if (remove) {
1867 pkt_dev->removal_mark = 1;
1868 t->control |= T_REMDEV;
1869 }
1870 break;
1871 }
1872 }
1873 return pkt_dev;
1874}
1875
1876
1877
1878
1879static void pktgen_mark_device(const struct pktgen_net *pn, const char *ifname)
1880{
1881 struct pktgen_dev *pkt_dev = NULL;
1882 const int max_tries = 10, msec_per_try = 125;
1883 int i = 0;
1884
1885 mutex_lock(&pktgen_thread_lock);
1886 pr_debug("%s: marking %s for removal\n", __func__, ifname);
1887
1888 while (1) {
1889
1890 pkt_dev = __pktgen_NN_threads(pn, ifname, REMOVE);
1891 if (pkt_dev == NULL)
1892 break;
1893
1894 mutex_unlock(&pktgen_thread_lock);
1895 pr_debug("%s: waiting for %s to disappear....\n",
1896 __func__, ifname);
1897 schedule_timeout_interruptible(msecs_to_jiffies(msec_per_try));
1898 mutex_lock(&pktgen_thread_lock);
1899
1900 if (++i >= max_tries) {
1901 pr_err("%s: timed out after waiting %d msec for device %s to be removed\n",
1902 __func__, msec_per_try * i, ifname);
1903 break;
1904 }
1905
1906 }
1907
1908 mutex_unlock(&pktgen_thread_lock);
1909}
1910
1911static void pktgen_change_name(const struct pktgen_net *pn, struct net_device *dev)
1912{
1913 struct pktgen_thread *t;
1914
1915 mutex_lock(&pktgen_thread_lock);
1916
1917 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
1918 struct pktgen_dev *pkt_dev;
1919
1920 if_lock(t);
1921 list_for_each_entry(pkt_dev, &t->if_list, list) {
1922 if (pkt_dev->odev != dev)
1923 continue;
1924
1925 proc_remove(pkt_dev->entry);
1926
1927 pkt_dev->entry = proc_create_data(dev->name, 0600,
1928 pn->proc_dir,
1929 &pktgen_if_fops,
1930 pkt_dev);
1931 if (!pkt_dev->entry)
1932 pr_err("can't move proc entry for '%s'\n",
1933 dev->name);
1934 break;
1935 }
1936 if_unlock(t);
1937 }
1938 mutex_unlock(&pktgen_thread_lock);
1939}
1940
1941static int pktgen_device_event(struct notifier_block *unused,
1942 unsigned long event, void *ptr)
1943{
1944 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
1945 struct pktgen_net *pn = net_generic(dev_net(dev), pg_net_id);
1946
1947 if (pn->pktgen_exiting)
1948 return NOTIFY_DONE;
1949
1950
1951
1952
1953
1954 switch (event) {
1955 case NETDEV_CHANGENAME:
1956 pktgen_change_name(pn, dev);
1957 break;
1958
1959 case NETDEV_UNREGISTER:
1960 pktgen_mark_device(pn, dev->name);
1961 break;
1962 }
1963
1964 return NOTIFY_DONE;
1965}
1966
1967static struct net_device *pktgen_dev_get_by_name(const struct pktgen_net *pn,
1968 struct pktgen_dev *pkt_dev,
1969 const char *ifname)
1970{
1971 char b[IFNAMSIZ+5];
1972 int i;
1973
1974 for (i = 0; ifname[i] != '@'; i++) {
1975 if (i == IFNAMSIZ)
1976 break;
1977
1978 b[i] = ifname[i];
1979 }
1980 b[i] = 0;
1981
1982 return dev_get_by_name(pn->net, b);
1983}
1984
1985
1986
1987
1988static int pktgen_setup_dev(const struct pktgen_net *pn,
1989 struct pktgen_dev *pkt_dev, const char *ifname)
1990{
1991 struct net_device *odev;
1992 int err;
1993
1994
1995 if (pkt_dev->odev) {
1996 dev_put(pkt_dev->odev);
1997 pkt_dev->odev = NULL;
1998 }
1999
2000 odev = pktgen_dev_get_by_name(pn, pkt_dev, ifname);
2001 if (!odev) {
2002 pr_err("no such netdevice: \"%s\"\n", ifname);
2003 return -ENODEV;
2004 }
2005
2006 if (odev->type != ARPHRD_ETHER) {
2007 pr_err("not an ethernet device: \"%s\"\n", ifname);
2008 err = -EINVAL;
2009 } else if (!netif_running(odev)) {
2010 pr_err("device is down: \"%s\"\n", ifname);
2011 err = -ENETDOWN;
2012 } else {
2013 pkt_dev->odev = odev;
2014 return 0;
2015 }
2016
2017 dev_put(odev);
2018 return err;
2019}
2020
2021
2022
2023
2024static void pktgen_setup_inject(struct pktgen_dev *pkt_dev)
2025{
2026 int ntxq;
2027
2028 if (!pkt_dev->odev) {
2029 pr_err("ERROR: pkt_dev->odev == NULL in setup_inject\n");
2030 sprintf(pkt_dev->result,
2031 "ERROR: pkt_dev->odev == NULL in setup_inject.\n");
2032 return;
2033 }
2034
2035
2036 ntxq = pkt_dev->odev->real_num_tx_queues;
2037
2038 if (ntxq <= pkt_dev->queue_map_min) {
2039 pr_warn("WARNING: Requested queue_map_min (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2040 pkt_dev->queue_map_min, (ntxq ?: 1) - 1, ntxq,
2041 pkt_dev->odevname);
2042 pkt_dev->queue_map_min = (ntxq ?: 1) - 1;
2043 }
2044 if (pkt_dev->queue_map_max >= ntxq) {
2045 pr_warn("WARNING: Requested queue_map_max (zero-based) (%d) exceeds valid range [0 - %d] for (%d) queues on %s, resetting\n",
2046 pkt_dev->queue_map_max, (ntxq ?: 1) - 1, ntxq,
2047 pkt_dev->odevname);
2048 pkt_dev->queue_map_max = (ntxq ?: 1) - 1;
2049 }
2050
2051
2052
2053 if (is_zero_ether_addr(pkt_dev->src_mac))
2054 ether_addr_copy(&(pkt_dev->hh[6]), pkt_dev->odev->dev_addr);
2055
2056
2057 ether_addr_copy(&(pkt_dev->hh[0]), pkt_dev->dst_mac);
2058
2059 if (pkt_dev->flags & F_IPV6) {
2060 int i, set = 0, err = 1;
2061 struct inet6_dev *idev;
2062
2063 if (pkt_dev->min_pkt_size == 0) {
2064 pkt_dev->min_pkt_size = 14 + sizeof(struct ipv6hdr)
2065 + sizeof(struct udphdr)
2066 + sizeof(struct pktgen_hdr)
2067 + pkt_dev->pkt_overhead;
2068 }
2069
2070 for (i = 0; i < sizeof(struct in6_addr); i++)
2071 if (pkt_dev->cur_in6_saddr.s6_addr[i]) {
2072 set = 1;
2073 break;
2074 }
2075
2076 if (!set) {
2077
2078
2079
2080
2081
2082
2083
2084 rcu_read_lock();
2085 idev = __in6_dev_get(pkt_dev->odev);
2086 if (idev) {
2087 struct inet6_ifaddr *ifp;
2088
2089 read_lock_bh(&idev->lock);
2090 list_for_each_entry(ifp, &idev->addr_list, if_list) {
2091 if ((ifp->scope & IFA_LINK) &&
2092 !(ifp->flags & IFA_F_TENTATIVE)) {
2093 pkt_dev->cur_in6_saddr = ifp->addr;
2094 err = 0;
2095 break;
2096 }
2097 }
2098 read_unlock_bh(&idev->lock);
2099 }
2100 rcu_read_unlock();
2101 if (err)
2102 pr_err("ERROR: IPv6 link address not available\n");
2103 }
2104 } else {
2105 if (pkt_dev->min_pkt_size == 0) {
2106 pkt_dev->min_pkt_size = 14 + sizeof(struct iphdr)
2107 + sizeof(struct udphdr)
2108 + sizeof(struct pktgen_hdr)
2109 + pkt_dev->pkt_overhead;
2110 }
2111
2112 pkt_dev->saddr_min = 0;
2113 pkt_dev->saddr_max = 0;
2114 if (strlen(pkt_dev->src_min) == 0) {
2115
2116 struct in_device *in_dev;
2117
2118 rcu_read_lock();
2119 in_dev = __in_dev_get_rcu(pkt_dev->odev);
2120 if (in_dev) {
2121 const struct in_ifaddr *ifa;
2122
2123 ifa = rcu_dereference(in_dev->ifa_list);
2124 if (ifa) {
2125 pkt_dev->saddr_min = ifa->ifa_address;
2126 pkt_dev->saddr_max = pkt_dev->saddr_min;
2127 }
2128 }
2129 rcu_read_unlock();
2130 } else {
2131 pkt_dev->saddr_min = in_aton(pkt_dev->src_min);
2132 pkt_dev->saddr_max = in_aton(pkt_dev->src_max);
2133 }
2134
2135 pkt_dev->daddr_min = in_aton(pkt_dev->dst_min);
2136 pkt_dev->daddr_max = in_aton(pkt_dev->dst_max);
2137 }
2138
2139 pkt_dev->cur_pkt_size = pkt_dev->min_pkt_size;
2140 if (pkt_dev->min_pkt_size > pkt_dev->max_pkt_size)
2141 pkt_dev->max_pkt_size = pkt_dev->min_pkt_size;
2142
2143 pkt_dev->cur_dst_mac_offset = 0;
2144 pkt_dev->cur_src_mac_offset = 0;
2145 pkt_dev->cur_saddr = pkt_dev->saddr_min;
2146 pkt_dev->cur_daddr = pkt_dev->daddr_min;
2147 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2148 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2149 pkt_dev->nflows = 0;
2150}
2151
2152
2153static void spin(struct pktgen_dev *pkt_dev, ktime_t spin_until)
2154{
2155 ktime_t start_time, end_time;
2156 s64 remaining;
2157 struct hrtimer_sleeper t;
2158
2159 hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
2160 hrtimer_set_expires(&t.timer, spin_until);
2161
2162 remaining = ktime_to_ns(hrtimer_expires_remaining(&t.timer));
2163 if (remaining <= 0)
2164 goto out;
2165
2166 start_time = ktime_get();
2167 if (remaining < 100000) {
2168
2169 do {
2170 end_time = ktime_get();
2171 } while (ktime_compare(end_time, spin_until) < 0);
2172 } else {
2173
2174 hrtimer_init_sleeper(&t, current);
2175 do {
2176 set_current_state(TASK_INTERRUPTIBLE);
2177 hrtimer_start_expires(&t.timer, HRTIMER_MODE_ABS);
2178
2179 if (likely(t.task))
2180 schedule();
2181
2182 hrtimer_cancel(&t.timer);
2183 } while (t.task && pkt_dev->running && !signal_pending(current));
2184 __set_current_state(TASK_RUNNING);
2185 end_time = ktime_get();
2186 }
2187
2188 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(end_time, start_time));
2189out:
2190 pkt_dev->next_tx = ktime_add_ns(spin_until, pkt_dev->delay);
2191 destroy_hrtimer_on_stack(&t.timer);
2192}
2193
2194static inline void set_pkt_overhead(struct pktgen_dev *pkt_dev)
2195{
2196 pkt_dev->pkt_overhead = 0;
2197 pkt_dev->pkt_overhead += pkt_dev->nr_labels*sizeof(u32);
2198 pkt_dev->pkt_overhead += VLAN_TAG_SIZE(pkt_dev);
2199 pkt_dev->pkt_overhead += SVLAN_TAG_SIZE(pkt_dev);
2200}
2201
2202static inline int f_seen(const struct pktgen_dev *pkt_dev, int flow)
2203{
2204 return !!(pkt_dev->flows[flow].flags & F_INIT);
2205}
2206
2207static inline int f_pick(struct pktgen_dev *pkt_dev)
2208{
2209 int flow = pkt_dev->curfl;
2210
2211 if (pkt_dev->flags & F_FLOW_SEQ) {
2212 if (pkt_dev->flows[flow].count >= pkt_dev->lflow) {
2213
2214 pkt_dev->flows[flow].count = 0;
2215 pkt_dev->flows[flow].flags = 0;
2216 pkt_dev->curfl += 1;
2217 if (pkt_dev->curfl >= pkt_dev->cflows)
2218 pkt_dev->curfl = 0;
2219 }
2220 } else {
2221 flow = prandom_u32() % pkt_dev->cflows;
2222 pkt_dev->curfl = flow;
2223
2224 if (pkt_dev->flows[flow].count > pkt_dev->lflow) {
2225 pkt_dev->flows[flow].count = 0;
2226 pkt_dev->flows[flow].flags = 0;
2227 }
2228 }
2229
2230 return pkt_dev->curfl;
2231}
2232
2233
2234#ifdef CONFIG_XFRM
2235
2236
2237
2238#define DUMMY_MARK 0
2239static void get_ipsec_sa(struct pktgen_dev *pkt_dev, int flow)
2240{
2241 struct xfrm_state *x = pkt_dev->flows[flow].x;
2242 struct pktgen_net *pn = net_generic(dev_net(pkt_dev->odev), pg_net_id);
2243 if (!x) {
2244
2245 if (pkt_dev->spi) {
2246
2247
2248
2249 x = xfrm_state_lookup_byspi(pn->net, htonl(pkt_dev->spi), AF_INET);
2250 } else {
2251
2252 x = xfrm_stateonly_find(pn->net, DUMMY_MARK, 0,
2253 (xfrm_address_t *)&pkt_dev->cur_daddr,
2254 (xfrm_address_t *)&pkt_dev->cur_saddr,
2255 AF_INET,
2256 pkt_dev->ipsmode,
2257 pkt_dev->ipsproto, 0);
2258 }
2259 if (x) {
2260 pkt_dev->flows[flow].x = x;
2261 set_pkt_overhead(pkt_dev);
2262 pkt_dev->pkt_overhead += x->props.header_len;
2263 }
2264
2265 }
2266}
2267#endif
2268static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
2269{
2270
2271 if (pkt_dev->flags & F_QUEUE_MAP_CPU)
2272 pkt_dev->cur_queue_map = smp_processor_id();
2273
2274 else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
2275 __u16 t;
2276 if (pkt_dev->flags & F_QUEUE_MAP_RND) {
2277 t = prandom_u32() %
2278 (pkt_dev->queue_map_max -
2279 pkt_dev->queue_map_min + 1)
2280 + pkt_dev->queue_map_min;
2281 } else {
2282 t = pkt_dev->cur_queue_map + 1;
2283 if (t > pkt_dev->queue_map_max)
2284 t = pkt_dev->queue_map_min;
2285 }
2286 pkt_dev->cur_queue_map = t;
2287 }
2288 pkt_dev->cur_queue_map = pkt_dev->cur_queue_map % pkt_dev->odev->real_num_tx_queues;
2289}
2290
2291
2292
2293
2294static void mod_cur_headers(struct pktgen_dev *pkt_dev)
2295{
2296 __u32 imn;
2297 __u32 imx;
2298 int flow = 0;
2299
2300 if (pkt_dev->cflows)
2301 flow = f_pick(pkt_dev);
2302
2303
2304 if (pkt_dev->src_mac_count > 1) {
2305 __u32 mc;
2306 __u32 tmp;
2307
2308 if (pkt_dev->flags & F_MACSRC_RND)
2309 mc = prandom_u32() % pkt_dev->src_mac_count;
2310 else {
2311 mc = pkt_dev->cur_src_mac_offset++;
2312 if (pkt_dev->cur_src_mac_offset >=
2313 pkt_dev->src_mac_count)
2314 pkt_dev->cur_src_mac_offset = 0;
2315 }
2316
2317 tmp = pkt_dev->src_mac[5] + (mc & 0xFF);
2318 pkt_dev->hh[11] = tmp;
2319 tmp = (pkt_dev->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2320 pkt_dev->hh[10] = tmp;
2321 tmp = (pkt_dev->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2322 pkt_dev->hh[9] = tmp;
2323 tmp = (pkt_dev->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2324 pkt_dev->hh[8] = tmp;
2325 tmp = (pkt_dev->src_mac[1] + (tmp >> 8));
2326 pkt_dev->hh[7] = tmp;
2327 }
2328
2329
2330 if (pkt_dev->dst_mac_count > 1) {
2331 __u32 mc;
2332 __u32 tmp;
2333
2334 if (pkt_dev->flags & F_MACDST_RND)
2335 mc = prandom_u32() % pkt_dev->dst_mac_count;
2336
2337 else {
2338 mc = pkt_dev->cur_dst_mac_offset++;
2339 if (pkt_dev->cur_dst_mac_offset >=
2340 pkt_dev->dst_mac_count) {
2341 pkt_dev->cur_dst_mac_offset = 0;
2342 }
2343 }
2344
2345 tmp = pkt_dev->dst_mac[5] + (mc & 0xFF);
2346 pkt_dev->hh[5] = tmp;
2347 tmp = (pkt_dev->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2348 pkt_dev->hh[4] = tmp;
2349 tmp = (pkt_dev->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2350 pkt_dev->hh[3] = tmp;
2351 tmp = (pkt_dev->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2352 pkt_dev->hh[2] = tmp;
2353 tmp = (pkt_dev->dst_mac[1] + (tmp >> 8));
2354 pkt_dev->hh[1] = tmp;
2355 }
2356
2357 if (pkt_dev->flags & F_MPLS_RND) {
2358 unsigned int i;
2359 for (i = 0; i < pkt_dev->nr_labels; i++)
2360 if (pkt_dev->labels[i] & MPLS_STACK_BOTTOM)
2361 pkt_dev->labels[i] = MPLS_STACK_BOTTOM |
2362 ((__force __be32)prandom_u32() &
2363 htonl(0x000fffff));
2364 }
2365
2366 if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
2367 pkt_dev->vlan_id = prandom_u32() & (4096 - 1);
2368 }
2369
2370 if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
2371 pkt_dev->svlan_id = prandom_u32() & (4096 - 1);
2372 }
2373
2374 if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
2375 if (pkt_dev->flags & F_UDPSRC_RND)
2376 pkt_dev->cur_udp_src = prandom_u32() %
2377 (pkt_dev->udp_src_max - pkt_dev->udp_src_min)
2378 + pkt_dev->udp_src_min;
2379
2380 else {
2381 pkt_dev->cur_udp_src++;
2382 if (pkt_dev->cur_udp_src >= pkt_dev->udp_src_max)
2383 pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2384 }
2385 }
2386
2387 if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
2388 if (pkt_dev->flags & F_UDPDST_RND) {
2389 pkt_dev->cur_udp_dst = prandom_u32() %
2390 (pkt_dev->udp_dst_max - pkt_dev->udp_dst_min)
2391 + pkt_dev->udp_dst_min;
2392 } else {
2393 pkt_dev->cur_udp_dst++;
2394 if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2395 pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2396 }
2397 }
2398
2399 if (!(pkt_dev->flags & F_IPV6)) {
2400
2401 imn = ntohl(pkt_dev->saddr_min);
2402 imx = ntohl(pkt_dev->saddr_max);
2403 if (imn < imx) {
2404 __u32 t;
2405 if (pkt_dev->flags & F_IPSRC_RND)
2406 t = prandom_u32() % (imx - imn) + imn;
2407 else {
2408 t = ntohl(pkt_dev->cur_saddr);
2409 t++;
2410 if (t > imx)
2411 t = imn;
2412
2413 }
2414 pkt_dev->cur_saddr = htonl(t);
2415 }
2416
2417 if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2418 pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2419 } else {
2420 imn = ntohl(pkt_dev->daddr_min);
2421 imx = ntohl(pkt_dev->daddr_max);
2422 if (imn < imx) {
2423 __u32 t;
2424 __be32 s;
2425 if (pkt_dev->flags & F_IPDST_RND) {
2426
2427 do {
2428 t = prandom_u32() %
2429 (imx - imn) + imn;
2430 s = htonl(t);
2431 } while (ipv4_is_loopback(s) ||
2432 ipv4_is_multicast(s) ||
2433 ipv4_is_lbcast(s) ||
2434 ipv4_is_zeronet(s) ||
2435 ipv4_is_local_multicast(s));
2436 pkt_dev->cur_daddr = s;
2437 } else {
2438 t = ntohl(pkt_dev->cur_daddr);
2439 t++;
2440 if (t > imx) {
2441 t = imn;
2442 }
2443 pkt_dev->cur_daddr = htonl(t);
2444 }
2445 }
2446 if (pkt_dev->cflows) {
2447 pkt_dev->flows[flow].flags |= F_INIT;
2448 pkt_dev->flows[flow].cur_daddr =
2449 pkt_dev->cur_daddr;
2450#ifdef CONFIG_XFRM
2451 if (pkt_dev->flags & F_IPSEC)
2452 get_ipsec_sa(pkt_dev, flow);
2453#endif
2454 pkt_dev->nflows++;
2455 }
2456 }
2457 } else {
2458
2459 if (!ipv6_addr_any(&pkt_dev->min_in6_daddr)) {
2460 int i;
2461
2462
2463
2464 for (i = 0; i < 4; i++) {
2465 pkt_dev->cur_in6_daddr.s6_addr32[i] =
2466 (((__force __be32)prandom_u32() |
2467 pkt_dev->min_in6_daddr.s6_addr32[i]) &
2468 pkt_dev->max_in6_daddr.s6_addr32[i]);
2469 }
2470 }
2471 }
2472
2473 if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
2474 __u32 t;
2475 if (pkt_dev->flags & F_TXSIZE_RND) {
2476 t = prandom_u32() %
2477 (pkt_dev->max_pkt_size - pkt_dev->min_pkt_size)
2478 + pkt_dev->min_pkt_size;
2479 } else {
2480 t = pkt_dev->cur_pkt_size + 1;
2481 if (t > pkt_dev->max_pkt_size)
2482 t = pkt_dev->min_pkt_size;
2483 }
2484 pkt_dev->cur_pkt_size = t;
2485 }
2486
2487 set_cur_queue_map(pkt_dev);
2488
2489 pkt_dev->flows[flow].count++;
2490}
2491
2492
2493#ifdef CONFIG_XFRM
2494static u32 pktgen_dst_metrics[RTAX_MAX + 1] = {
2495
2496 [RTAX_HOPLIMIT] = 0x5,
2497};
2498
2499static int pktgen_output_ipsec(struct sk_buff *skb, struct pktgen_dev *pkt_dev)
2500{
2501 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2502 int err = 0;
2503 struct net *net = dev_net(pkt_dev->odev);
2504
2505 if (!x)
2506 return 0;
2507
2508
2509 if ((x->props.mode != XFRM_MODE_TRANSPORT) && (pkt_dev->spi == 0))
2510 return 0;
2511
2512
2513
2514
2515 if ((x->props.mode == XFRM_MODE_TUNNEL) && (pkt_dev->spi != 0))
2516 skb->_skb_refdst = (unsigned long)&pkt_dev->xdst.u.dst | SKB_DST_NOREF;
2517
2518 rcu_read_lock_bh();
2519 err = pktgen_xfrm_outer_mode_output(x, skb);
2520 rcu_read_unlock_bh();
2521 if (err) {
2522 XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEMODEERROR);
2523 goto error;
2524 }
2525 err = x->type->output(x, skb);
2526 if (err) {
2527 XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEPROTOERROR);
2528 goto error;
2529 }
2530 spin_lock_bh(&x->lock);
2531 x->curlft.bytes += skb->len;
2532 x->curlft.packets++;
2533 spin_unlock_bh(&x->lock);
2534error:
2535 return err;
2536}
2537
2538static void free_SAs(struct pktgen_dev *pkt_dev)
2539{
2540 if (pkt_dev->cflows) {
2541
2542 int i;
2543 for (i = 0; i < pkt_dev->cflows; i++) {
2544 struct xfrm_state *x = pkt_dev->flows[i].x;
2545 if (x) {
2546 xfrm_state_put(x);
2547 pkt_dev->flows[i].x = NULL;
2548 }
2549 }
2550 }
2551}
2552
2553static int process_ipsec(struct pktgen_dev *pkt_dev,
2554 struct sk_buff *skb, __be16 protocol)
2555{
2556 if (pkt_dev->flags & F_IPSEC) {
2557 struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2558 int nhead = 0;
2559 if (x) {
2560 struct ethhdr *eth;
2561 struct iphdr *iph;
2562 int ret;
2563
2564 nhead = x->props.header_len - skb_headroom(skb);
2565 if (nhead > 0) {
2566 ret = pskb_expand_head(skb, nhead, 0, GFP_ATOMIC);
2567 if (ret < 0) {
2568 pr_err("Error expanding ipsec packet %d\n",
2569 ret);
2570 goto err;
2571 }
2572 }
2573
2574
2575 skb_pull(skb, ETH_HLEN);
2576 ret = pktgen_output_ipsec(skb, pkt_dev);
2577 if (ret) {
2578 pr_err("Error creating ipsec packet %d\n", ret);
2579 goto err;
2580 }
2581
2582 eth = skb_push(skb, ETH_HLEN);
2583 memcpy(eth, pkt_dev->hh, 2 * ETH_ALEN);
2584 eth->h_proto = protocol;
2585
2586
2587 iph = ip_hdr(skb);
2588 iph->tot_len = htons(skb->len - ETH_HLEN);
2589 ip_send_check(iph);
2590 }
2591 }
2592 return 1;
2593err:
2594 kfree_skb(skb);
2595 return 0;
2596}
2597#endif
2598
2599static void mpls_push(__be32 *mpls, struct pktgen_dev *pkt_dev)
2600{
2601 unsigned int i;
2602 for (i = 0; i < pkt_dev->nr_labels; i++)
2603 *mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2604
2605 mpls--;
2606 *mpls |= MPLS_STACK_BOTTOM;
2607}
2608
2609static inline __be16 build_tci(unsigned int id, unsigned int cfi,
2610 unsigned int prio)
2611{
2612 return htons(id | (cfi << 12) | (prio << 13));
2613}
2614
2615static void pktgen_finalize_skb(struct pktgen_dev *pkt_dev, struct sk_buff *skb,
2616 int datalen)
2617{
2618 struct timespec64 timestamp;
2619 struct pktgen_hdr *pgh;
2620
2621 pgh = skb_put(skb, sizeof(*pgh));
2622 datalen -= sizeof(*pgh);
2623
2624 if (pkt_dev->nfrags <= 0) {
2625 skb_put_zero(skb, datalen);
2626 } else {
2627 int frags = pkt_dev->nfrags;
2628 int i, len;
2629 int frag_len;
2630
2631
2632 if (frags > MAX_SKB_FRAGS)
2633 frags = MAX_SKB_FRAGS;
2634 len = datalen - frags * PAGE_SIZE;
2635 if (len > 0) {
2636 skb_put_zero(skb, len);
2637 datalen = frags * PAGE_SIZE;
2638 }
2639
2640 i = 0;
2641 frag_len = (datalen/frags) < PAGE_SIZE ?
2642 (datalen/frags) : PAGE_SIZE;
2643 while (datalen > 0) {
2644 if (unlikely(!pkt_dev->page)) {
2645 int node = numa_node_id();
2646
2647 if (pkt_dev->node >= 0 && (pkt_dev->flags & F_NODE))
2648 node = pkt_dev->node;
2649 pkt_dev->page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO, 0);
2650 if (!pkt_dev->page)
2651 break;
2652 }
2653 get_page(pkt_dev->page);
2654 skb_frag_set_page(skb, i, pkt_dev->page);
2655 skb_shinfo(skb)->frags[i].page_offset = 0;
2656
2657 if (i == (frags - 1))
2658 skb_frag_size_set(&skb_shinfo(skb)->frags[i],
2659 (datalen < PAGE_SIZE ? datalen : PAGE_SIZE));
2660 else
2661 skb_frag_size_set(&skb_shinfo(skb)->frags[i], frag_len);
2662 datalen -= skb_frag_size(&skb_shinfo(skb)->frags[i]);
2663 skb->len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2664 skb->data_len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2665 i++;
2666 skb_shinfo(skb)->nr_frags = i;
2667 }
2668 }
2669
2670
2671
2672
2673 pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2674 pgh->seq_num = htonl(pkt_dev->seq_num);
2675
2676 if (pkt_dev->flags & F_NO_TIMESTAMP) {
2677 pgh->tv_sec = 0;
2678 pgh->tv_usec = 0;
2679 } else {
2680
2681
2682
2683
2684
2685
2686
2687
2688 ktime_get_real_ts64(×tamp);
2689 pgh->tv_sec = htonl(timestamp.tv_sec);
2690 pgh->tv_usec = htonl(timestamp.tv_nsec / NSEC_PER_USEC);
2691 }
2692}
2693
2694static struct sk_buff *pktgen_alloc_skb(struct net_device *dev,
2695 struct pktgen_dev *pkt_dev)
2696{
2697 unsigned int extralen = LL_RESERVED_SPACE(dev);
2698 struct sk_buff *skb = NULL;
2699 unsigned int size;
2700
2701 size = pkt_dev->cur_pkt_size + 64 + extralen + pkt_dev->pkt_overhead;
2702 if (pkt_dev->flags & F_NODE) {
2703 int node = pkt_dev->node >= 0 ? pkt_dev->node : numa_node_id();
2704
2705 skb = __alloc_skb(NET_SKB_PAD + size, GFP_NOWAIT, 0, node);
2706 if (likely(skb)) {
2707 skb_reserve(skb, NET_SKB_PAD);
2708 skb->dev = dev;
2709 }
2710 } else {
2711 skb = __netdev_alloc_skb(dev, size, GFP_NOWAIT);
2712 }
2713
2714
2715 if (likely(skb))
2716 skb_reserve(skb, extralen - 16);
2717
2718 return skb;
2719}
2720
2721static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
2722 struct pktgen_dev *pkt_dev)
2723{
2724 struct sk_buff *skb = NULL;
2725 __u8 *eth;
2726 struct udphdr *udph;
2727 int datalen, iplen;
2728 struct iphdr *iph;
2729 __be16 protocol = htons(ETH_P_IP);
2730 __be32 *mpls;
2731 __be16 *vlan_tci = NULL;
2732 __be16 *vlan_encapsulated_proto = NULL;
2733 __be16 *svlan_tci = NULL;
2734 __be16 *svlan_encapsulated_proto = NULL;
2735 u16 queue_map;
2736
2737 if (pkt_dev->nr_labels)
2738 protocol = htons(ETH_P_MPLS_UC);
2739
2740 if (pkt_dev->vlan_id != 0xffff)
2741 protocol = htons(ETH_P_8021Q);
2742
2743
2744
2745
2746 mod_cur_headers(pkt_dev);
2747 queue_map = pkt_dev->cur_queue_map;
2748
2749 skb = pktgen_alloc_skb(odev, pkt_dev);
2750 if (!skb) {
2751 sprintf(pkt_dev->result, "No memory");
2752 return NULL;
2753 }
2754
2755 prefetchw(skb->data);
2756 skb_reserve(skb, 16);
2757
2758
2759 eth = skb_push(skb, 14);
2760 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2761 if (pkt_dev->nr_labels)
2762 mpls_push(mpls, pkt_dev);
2763
2764 if (pkt_dev->vlan_id != 0xffff) {
2765 if (pkt_dev->svlan_id != 0xffff) {
2766 svlan_tci = skb_put(skb, sizeof(__be16));
2767 *svlan_tci = build_tci(pkt_dev->svlan_id,
2768 pkt_dev->svlan_cfi,
2769 pkt_dev->svlan_p);
2770 svlan_encapsulated_proto = skb_put(skb,
2771 sizeof(__be16));
2772 *svlan_encapsulated_proto = htons(ETH_P_8021Q);
2773 }
2774 vlan_tci = skb_put(skb, sizeof(__be16));
2775 *vlan_tci = build_tci(pkt_dev->vlan_id,
2776 pkt_dev->vlan_cfi,
2777 pkt_dev->vlan_p);
2778 vlan_encapsulated_proto = skb_put(skb, sizeof(__be16));
2779 *vlan_encapsulated_proto = htons(ETH_P_IP);
2780 }
2781
2782 skb_reset_mac_header(skb);
2783 skb_set_network_header(skb, skb->len);
2784 iph = skb_put(skb, sizeof(struct iphdr));
2785
2786 skb_set_transport_header(skb, skb->len);
2787 udph = skb_put(skb, sizeof(struct udphdr));
2788 skb_set_queue_mapping(skb, queue_map);
2789 skb->priority = pkt_dev->skb_priority;
2790
2791 memcpy(eth, pkt_dev->hh, 12);
2792 *(__be16 *) & eth[12] = protocol;
2793
2794
2795 datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 -
2796 pkt_dev->pkt_overhead;
2797 if (datalen < 0 || datalen < sizeof(struct pktgen_hdr))
2798 datalen = sizeof(struct pktgen_hdr);
2799
2800 udph->source = htons(pkt_dev->cur_udp_src);
2801 udph->dest = htons(pkt_dev->cur_udp_dst);
2802 udph->len = htons(datalen + 8);
2803 udph->check = 0;
2804
2805 iph->ihl = 5;
2806 iph->version = 4;
2807 iph->ttl = 32;
2808 iph->tos = pkt_dev->tos;
2809 iph->protocol = IPPROTO_UDP;
2810 iph->saddr = pkt_dev->cur_saddr;
2811 iph->daddr = pkt_dev->cur_daddr;
2812 iph->id = htons(pkt_dev->ip_id);
2813 pkt_dev->ip_id++;
2814 iph->frag_off = 0;
2815 iplen = 20 + 8 + datalen;
2816 iph->tot_len = htons(iplen);
2817 ip_send_check(iph);
2818 skb->protocol = protocol;
2819 skb->dev = odev;
2820 skb->pkt_type = PACKET_HOST;
2821
2822 pktgen_finalize_skb(pkt_dev, skb, datalen);
2823
2824 if (!(pkt_dev->flags & F_UDPCSUM)) {
2825 skb->ip_summed = CHECKSUM_NONE;
2826 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM)) {
2827 skb->ip_summed = CHECKSUM_PARTIAL;
2828 skb->csum = 0;
2829 udp4_hwcsum(skb, iph->saddr, iph->daddr);
2830 } else {
2831 __wsum csum = skb_checksum(skb, skb_transport_offset(skb), datalen + 8, 0);
2832
2833
2834 udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
2835 datalen + 8, IPPROTO_UDP, csum);
2836
2837 if (udph->check == 0)
2838 udph->check = CSUM_MANGLED_0;
2839 }
2840
2841#ifdef CONFIG_XFRM
2842 if (!process_ipsec(pkt_dev, skb, protocol))
2843 return NULL;
2844#endif
2845
2846 return skb;
2847}
2848
2849static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
2850 struct pktgen_dev *pkt_dev)
2851{
2852 struct sk_buff *skb = NULL;
2853 __u8 *eth;
2854 struct udphdr *udph;
2855 int datalen, udplen;
2856 struct ipv6hdr *iph;
2857 __be16 protocol = htons(ETH_P_IPV6);
2858 __be32 *mpls;
2859 __be16 *vlan_tci = NULL;
2860 __be16 *vlan_encapsulated_proto = NULL;
2861 __be16 *svlan_tci = NULL;
2862 __be16 *svlan_encapsulated_proto = NULL;
2863 u16 queue_map;
2864
2865 if (pkt_dev->nr_labels)
2866 protocol = htons(ETH_P_MPLS_UC);
2867
2868 if (pkt_dev->vlan_id != 0xffff)
2869 protocol = htons(ETH_P_8021Q);
2870
2871
2872
2873
2874 mod_cur_headers(pkt_dev);
2875 queue_map = pkt_dev->cur_queue_map;
2876
2877 skb = pktgen_alloc_skb(odev, pkt_dev);
2878 if (!skb) {
2879 sprintf(pkt_dev->result, "No memory");
2880 return NULL;
2881 }
2882
2883 prefetchw(skb->data);
2884 skb_reserve(skb, 16);
2885
2886
2887 eth = skb_push(skb, 14);
2888 mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2889 if (pkt_dev->nr_labels)
2890 mpls_push(mpls, pkt_dev);
2891
2892 if (pkt_dev->vlan_id != 0xffff) {
2893 if (pkt_dev->svlan_id != 0xffff) {
2894 svlan_tci = skb_put(skb, sizeof(__be16));
2895 *svlan_tci = build_tci(pkt_dev->svlan_id,
2896 pkt_dev->svlan_cfi,
2897 pkt_dev->svlan_p);
2898 svlan_encapsulated_proto = skb_put(skb,
2899 sizeof(__be16));
2900 *svlan_encapsulated_proto = htons(ETH_P_8021Q);
2901 }
2902 vlan_tci = skb_put(skb, sizeof(__be16));
2903 *vlan_tci = build_tci(pkt_dev->vlan_id,
2904 pkt_dev->vlan_cfi,
2905 pkt_dev->vlan_p);
2906 vlan_encapsulated_proto = skb_put(skb, sizeof(__be16));
2907 *vlan_encapsulated_proto = htons(ETH_P_IPV6);
2908 }
2909
2910 skb_reset_mac_header(skb);
2911 skb_set_network_header(skb, skb->len);
2912 iph = skb_put(skb, sizeof(struct ipv6hdr));
2913
2914 skb_set_transport_header(skb, skb->len);
2915 udph = skb_put(skb, sizeof(struct udphdr));
2916 skb_set_queue_mapping(skb, queue_map);
2917 skb->priority = pkt_dev->skb_priority;
2918
2919 memcpy(eth, pkt_dev->hh, 12);
2920 *(__be16 *) ð[12] = protocol;
2921
2922
2923 datalen = pkt_dev->cur_pkt_size - 14 -
2924 sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
2925 pkt_dev->pkt_overhead;
2926
2927 if (datalen < 0 || datalen < sizeof(struct pktgen_hdr)) {
2928 datalen = sizeof(struct pktgen_hdr);
2929 net_info_ratelimited("increased datalen to %d\n", datalen);
2930 }
2931
2932 udplen = datalen + sizeof(struct udphdr);
2933 udph->source = htons(pkt_dev->cur_udp_src);
2934 udph->dest = htons(pkt_dev->cur_udp_dst);
2935 udph->len = htons(udplen);
2936 udph->check = 0;
2937
2938 *(__be32 *) iph = htonl(0x60000000);
2939
2940 if (pkt_dev->traffic_class) {
2941
2942 *(__be32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20));
2943 }
2944
2945 iph->hop_limit = 32;
2946
2947 iph->payload_len = htons(udplen);
2948 iph->nexthdr = IPPROTO_UDP;
2949
2950 iph->daddr = pkt_dev->cur_in6_daddr;
2951 iph->saddr = pkt_dev->cur_in6_saddr;
2952
2953 skb->protocol = protocol;
2954 skb->dev = odev;
2955 skb->pkt_type = PACKET_HOST;
2956
2957 pktgen_finalize_skb(pkt_dev, skb, datalen);
2958
2959 if (!(pkt_dev->flags & F_UDPCSUM)) {
2960 skb->ip_summed = CHECKSUM_NONE;
2961 } else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IPV6_CSUM)) {
2962 skb->ip_summed = CHECKSUM_PARTIAL;
2963 skb->csum_start = skb_transport_header(skb) - skb->head;
2964 skb->csum_offset = offsetof(struct udphdr, check);
2965 udph->check = ~csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, 0);
2966 } else {
2967 __wsum csum = skb_checksum(skb, skb_transport_offset(skb), udplen, 0);
2968
2969
2970 udph->check = csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, csum);
2971
2972 if (udph->check == 0)
2973 udph->check = CSUM_MANGLED_0;
2974 }
2975
2976 return skb;
2977}
2978
2979static struct sk_buff *fill_packet(struct net_device *odev,
2980 struct pktgen_dev *pkt_dev)
2981{
2982 if (pkt_dev->flags & F_IPV6)
2983 return fill_packet_ipv6(odev, pkt_dev);
2984 else
2985 return fill_packet_ipv4(odev, pkt_dev);
2986}
2987
2988static void pktgen_clear_counters(struct pktgen_dev *pkt_dev)
2989{
2990 pkt_dev->seq_num = 1;
2991 pkt_dev->idle_acc = 0;
2992 pkt_dev->sofar = 0;
2993 pkt_dev->tx_bytes = 0;
2994 pkt_dev->errors = 0;
2995}
2996
2997
2998
2999static void pktgen_run(struct pktgen_thread *t)
3000{
3001 struct pktgen_dev *pkt_dev;
3002 int started = 0;
3003
3004 func_enter();
3005
3006 rcu_read_lock();
3007 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3008
3009
3010
3011
3012 pktgen_setup_inject(pkt_dev);
3013
3014 if (pkt_dev->odev) {
3015 pktgen_clear_counters(pkt_dev);
3016 pkt_dev->skb = NULL;
3017 pkt_dev->started_at = pkt_dev->next_tx = ktime_get();
3018
3019 set_pkt_overhead(pkt_dev);
3020
3021 strcpy(pkt_dev->result, "Starting");
3022 pkt_dev->running = 1;
3023 started++;
3024 } else
3025 strcpy(pkt_dev->result, "Error starting");
3026 }
3027 rcu_read_unlock();
3028 if (started)
3029 t->control &= ~(T_STOP);
3030}
3031
3032static void pktgen_stop_all_threads_ifs(struct pktgen_net *pn)
3033{
3034 struct pktgen_thread *t;
3035
3036 func_enter();
3037
3038 mutex_lock(&pktgen_thread_lock);
3039
3040 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3041 t->control |= T_STOP;
3042
3043 mutex_unlock(&pktgen_thread_lock);
3044}
3045
3046static int thread_is_running(const struct pktgen_thread *t)
3047{
3048 const struct pktgen_dev *pkt_dev;
3049
3050 rcu_read_lock();
3051 list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
3052 if (pkt_dev->running) {
3053 rcu_read_unlock();
3054 return 1;
3055 }
3056 rcu_read_unlock();
3057 return 0;
3058}
3059
3060static int pktgen_wait_thread_run(struct pktgen_thread *t)
3061{
3062 while (thread_is_running(t)) {
3063
3064
3065
3066
3067
3068 mutex_unlock(&pktgen_thread_lock);
3069 msleep_interruptible(100);
3070 mutex_lock(&pktgen_thread_lock);
3071
3072 if (signal_pending(current))
3073 goto signal;
3074 }
3075 return 1;
3076signal:
3077 return 0;
3078}
3079
3080static int pktgen_wait_all_threads_run(struct pktgen_net *pn)
3081{
3082 struct pktgen_thread *t;
3083 int sig = 1;
3084
3085
3086 if (!try_module_get(THIS_MODULE))
3087 return sig;
3088
3089 mutex_lock(&pktgen_thread_lock);
3090
3091 list_for_each_entry(t, &pn->pktgen_threads, th_list) {
3092 sig = pktgen_wait_thread_run(t);
3093 if (sig == 0)
3094 break;
3095 }
3096
3097 if (sig == 0)
3098 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3099 t->control |= (T_STOP);
3100
3101 mutex_unlock(&pktgen_thread_lock);
3102 module_put(THIS_MODULE);
3103 return sig;
3104}
3105
3106static void pktgen_run_all_threads(struct pktgen_net *pn)
3107{
3108 struct pktgen_thread *t;
3109
3110 func_enter();
3111
3112 mutex_lock(&pktgen_thread_lock);
3113
3114 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3115 t->control |= (T_RUN);
3116
3117 mutex_unlock(&pktgen_thread_lock);
3118
3119
3120 schedule_timeout_interruptible(msecs_to_jiffies(125));
3121
3122 pktgen_wait_all_threads_run(pn);
3123}
3124
3125static void pktgen_reset_all_threads(struct pktgen_net *pn)
3126{
3127 struct pktgen_thread *t;
3128
3129 func_enter();
3130
3131 mutex_lock(&pktgen_thread_lock);
3132
3133 list_for_each_entry(t, &pn->pktgen_threads, th_list)
3134 t->control |= (T_REMDEVALL);
3135
3136 mutex_unlock(&pktgen_thread_lock);
3137
3138
3139 schedule_timeout_interruptible(msecs_to_jiffies(125));
3140
3141 pktgen_wait_all_threads_run(pn);
3142}
3143
3144static void show_results(struct pktgen_dev *pkt_dev, int nr_frags)
3145{
3146 __u64 bps, mbps, pps;
3147 char *p = pkt_dev->result;
3148 ktime_t elapsed = ktime_sub(pkt_dev->stopped_at,
3149 pkt_dev->started_at);
3150 ktime_t idle = ns_to_ktime(pkt_dev->idle_acc);
3151
3152 p += sprintf(p, "OK: %llu(c%llu+d%llu) usec, %llu (%dbyte,%dfrags)\n",
3153 (unsigned long long)ktime_to_us(elapsed),
3154 (unsigned long long)ktime_to_us(ktime_sub(elapsed, idle)),
3155 (unsigned long long)ktime_to_us(idle),
3156 (unsigned long long)pkt_dev->sofar,
3157 pkt_dev->cur_pkt_size, nr_frags);
3158
3159 pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,
3160 ktime_to_ns(elapsed));
3161
3162 bps = pps * 8 * pkt_dev->cur_pkt_size;
3163
3164 mbps = bps;
3165 do_div(mbps, 1000000);
3166 p += sprintf(p, " %llupps %lluMb/sec (%llubps) errors: %llu",
3167 (unsigned long long)pps,
3168 (unsigned long long)mbps,
3169 (unsigned long long)bps,
3170 (unsigned long long)pkt_dev->errors);
3171}
3172
3173
3174static int pktgen_stop_device(struct pktgen_dev *pkt_dev)
3175{
3176 int nr_frags = pkt_dev->skb ? skb_shinfo(pkt_dev->skb)->nr_frags : -1;
3177
3178 if (!pkt_dev->running) {
3179 pr_warn("interface: %s is already stopped\n",
3180 pkt_dev->odevname);
3181 return -EINVAL;
3182 }
3183
3184 pkt_dev->running = 0;
3185 kfree_skb(pkt_dev->skb);
3186 pkt_dev->skb = NULL;
3187 pkt_dev->stopped_at = ktime_get();
3188
3189 show_results(pkt_dev, nr_frags);
3190
3191 return 0;
3192}
3193
3194static struct pktgen_dev *next_to_run(struct pktgen_thread *t)
3195{
3196 struct pktgen_dev *pkt_dev, *best = NULL;
3197
3198 rcu_read_lock();
3199 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3200 if (!pkt_dev->running)
3201 continue;
3202 if (best == NULL)
3203 best = pkt_dev;
3204 else if (ktime_compare(pkt_dev->next_tx, best->next_tx) < 0)
3205 best = pkt_dev;
3206 }
3207 rcu_read_unlock();
3208
3209 return best;
3210}
3211
3212static void pktgen_stop(struct pktgen_thread *t)
3213{
3214 struct pktgen_dev *pkt_dev;
3215
3216 func_enter();
3217
3218 rcu_read_lock();
3219
3220 list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3221 pktgen_stop_device(pkt_dev);
3222 }
3223
3224 rcu_read_unlock();
3225}
3226
3227
3228
3229
3230
3231static void pktgen_rem_one_if(struct pktgen_thread *t)
3232{
3233 struct list_head *q, *n;
3234 struct pktgen_dev *cur;
3235
3236 func_enter();
3237
3238 list_for_each_safe(q, n, &t->if_list) {
3239 cur = list_entry(q, struct pktgen_dev, list);
3240
3241 if (!cur->removal_mark)
3242 continue;
3243
3244 kfree_skb(cur->skb);
3245 cur->skb = NULL;
3246
3247 pktgen_remove_device(t, cur);
3248
3249 break;
3250 }
3251}
3252
3253static void pktgen_rem_all_ifs(struct pktgen_thread *t)
3254{
3255 struct list_head *q, *n;
3256 struct pktgen_dev *cur;
3257
3258 func_enter();
3259
3260
3261
3262 list_for_each_safe(q, n, &t->if_list) {
3263 cur = list_entry(q, struct pktgen_dev, list);
3264
3265 kfree_skb(cur->skb);
3266 cur->skb = NULL;
3267
3268 pktgen_remove_device(t, cur);
3269 }
3270}
3271
3272static void pktgen_rem_thread(struct pktgen_thread *t)
3273{
3274
3275 remove_proc_entry(t->tsk->comm, t->net->proc_dir);
3276}
3277
3278static void pktgen_resched(struct pktgen_dev *pkt_dev)
3279{
3280 ktime_t idle_start = ktime_get();
3281 schedule();
3282 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3283}
3284
3285static void pktgen_wait_for_skb(struct pktgen_dev *pkt_dev)
3286{
3287 ktime_t idle_start = ktime_get();
3288
3289 while (refcount_read(&(pkt_dev->skb->users)) != 1) {
3290 if (signal_pending(current))
3291 break;
3292
3293 if (need_resched())
3294 pktgen_resched(pkt_dev);
3295 else
3296 cpu_relax();
3297 }
3298 pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3299}
3300
3301static void pktgen_xmit(struct pktgen_dev *pkt_dev)
3302{
3303 unsigned int burst = READ_ONCE(pkt_dev->burst);
3304 struct net_device *odev = pkt_dev->odev;
3305 struct netdev_queue *txq;
3306 struct sk_buff *skb;
3307 int ret;
3308
3309
3310 if (unlikely(!netif_running(odev) || !netif_carrier_ok(odev))) {
3311 pktgen_stop_device(pkt_dev);
3312 return;
3313 }
3314
3315
3316
3317
3318 if (unlikely(pkt_dev->delay == ULLONG_MAX)) {
3319 pkt_dev->next_tx = ktime_add_ns(ktime_get(), ULONG_MAX);
3320 return;
3321 }
3322
3323
3324 if (!pkt_dev->skb || (pkt_dev->last_ok &&
3325 ++pkt_dev->clone_count >= pkt_dev->clone_skb)) {
3326
3327 kfree_skb(pkt_dev->skb);
3328
3329 pkt_dev->skb = fill_packet(odev, pkt_dev);
3330 if (pkt_dev->skb == NULL) {
3331 pr_err("ERROR: couldn't allocate skb in fill_packet\n");
3332 schedule();
3333 pkt_dev->clone_count--;
3334 return;
3335 }
3336 pkt_dev->last_pkt_size = pkt_dev->skb->len;
3337 pkt_dev->clone_count = 0;
3338 }
3339
3340 if (pkt_dev->delay && pkt_dev->last_ok)
3341 spin(pkt_dev, pkt_dev->next_tx);
3342
3343 if (pkt_dev->xmit_mode == M_NETIF_RECEIVE) {
3344 skb = pkt_dev->skb;
3345 skb->protocol = eth_type_trans(skb, skb->dev);
3346 refcount_add(burst, &skb->users);
3347 local_bh_disable();
3348 do {
3349 ret = netif_receive_skb(skb);
3350 if (ret == NET_RX_DROP)
3351 pkt_dev->errors++;
3352 pkt_dev->sofar++;
3353 pkt_dev->seq_num++;
3354 if (refcount_read(&skb->users) != burst) {
3355
3356
3357
3358 WARN_ON(refcount_sub_and_test(burst - 1, &skb->users));
3359
3360
3361
3362 break;
3363 }
3364
3365
3366
3367 skb_reset_tc(skb);
3368 } while (--burst > 0);
3369 goto out;
3370 } else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {
3371 local_bh_disable();
3372 refcount_inc(&pkt_dev->skb->users);
3373
3374 ret = dev_queue_xmit(pkt_dev->skb);
3375 switch (ret) {
3376 case NET_XMIT_SUCCESS:
3377 pkt_dev->sofar++;
3378 pkt_dev->seq_num++;
3379 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3380 break;
3381 case NET_XMIT_DROP:
3382 case NET_XMIT_CN:
3383
3384
3385
3386
3387 case NETDEV_TX_BUSY:
3388
3389
3390
3391
3392
3393 default:
3394 pkt_dev->errors++;
3395 net_info_ratelimited("%s xmit error: %d\n",
3396 pkt_dev->odevname, ret);
3397 break;
3398 }
3399 goto out;
3400 }
3401
3402 txq = skb_get_tx_queue(odev, pkt_dev->skb);
3403
3404 local_bh_disable();
3405
3406 HARD_TX_LOCK(odev, txq, smp_processor_id());
3407
3408 if (unlikely(netif_xmit_frozen_or_drv_stopped(txq))) {
3409 ret = NETDEV_TX_BUSY;
3410 pkt_dev->last_ok = 0;
3411 goto unlock;
3412 }
3413 refcount_add(burst, &pkt_dev->skb->users);
3414
3415xmit_more:
3416 ret = netdev_start_xmit(pkt_dev->skb, odev, txq, --burst > 0);
3417
3418 switch (ret) {
3419 case NETDEV_TX_OK:
3420 pkt_dev->last_ok = 1;
3421 pkt_dev->sofar++;
3422 pkt_dev->seq_num++;
3423 pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3424 if (burst > 0 && !netif_xmit_frozen_or_drv_stopped(txq))
3425 goto xmit_more;
3426 break;
3427 case NET_XMIT_DROP:
3428 case NET_XMIT_CN:
3429
3430 pkt_dev->errors++;
3431 break;
3432 default:
3433 net_info_ratelimited("%s xmit error: %d\n",
3434 pkt_dev->odevname, ret);
3435 pkt_dev->errors++;
3436
3437 case NETDEV_TX_BUSY:
3438
3439 refcount_dec(&(pkt_dev->skb->users));
3440 pkt_dev->last_ok = 0;
3441 }
3442 if (unlikely(burst))
3443 WARN_ON(refcount_sub_and_test(burst, &pkt_dev->skb->users));
3444unlock:
3445 HARD_TX_UNLOCK(odev, txq);
3446
3447out:
3448 local_bh_enable();
3449
3450
3451 if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) {
3452 pktgen_wait_for_skb(pkt_dev);
3453
3454
3455 pktgen_stop_device(pkt_dev);
3456 }
3457}
3458
3459
3460
3461
3462
3463static int pktgen_thread_worker(void *arg)
3464{
3465 DEFINE_WAIT(wait);
3466 struct pktgen_thread *t = arg;
3467 struct pktgen_dev *pkt_dev = NULL;
3468 int cpu = t->cpu;
3469
3470 BUG_ON(smp_processor_id() != cpu);
3471
3472 init_waitqueue_head(&t->queue);
3473 complete(&t->start_done);
3474
3475 pr_debug("starting pktgen/%d: pid=%d\n", cpu, task_pid_nr(current));
3476
3477 set_freezable();
3478
3479 while (!kthread_should_stop()) {
3480 pkt_dev = next_to_run(t);
3481
3482 if (unlikely(!pkt_dev && t->control == 0)) {
3483 if (t->net->pktgen_exiting)
3484 break;
3485 wait_event_interruptible_timeout(t->queue,
3486 t->control != 0,
3487 HZ/10);
3488 try_to_freeze();
3489 continue;
3490 }
3491
3492 if (likely(pkt_dev)) {
3493 pktgen_xmit(pkt_dev);
3494
3495 if (need_resched())
3496 pktgen_resched(pkt_dev);
3497 else
3498 cpu_relax();
3499 }
3500
3501 if (t->control & T_STOP) {
3502 pktgen_stop(t);
3503 t->control &= ~(T_STOP);
3504 }
3505
3506 if (t->control & T_RUN) {
3507 pktgen_run(t);
3508 t->control &= ~(T_RUN);
3509 }
3510
3511 if (t->control & T_REMDEVALL) {
3512 pktgen_rem_all_ifs(t);
3513 t->control &= ~(T_REMDEVALL);
3514 }
3515
3516 if (t->control & T_REMDEV) {
3517 pktgen_rem_one_if(t);
3518 t->control &= ~(T_REMDEV);
3519 }
3520
3521 try_to_freeze();
3522 }
3523
3524 pr_debug("%s stopping all device\n", t->tsk->comm);
3525 pktgen_stop(t);
3526
3527 pr_debug("%s removing all device\n", t->tsk->comm);
3528 pktgen_rem_all_ifs(t);
3529
3530 pr_debug("%s removing thread\n", t->tsk->comm);
3531 pktgen_rem_thread(t);
3532
3533 return 0;
3534}
3535
3536static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t,
3537 const char *ifname, bool exact)
3538{
3539 struct pktgen_dev *p, *pkt_dev = NULL;
3540 size_t len = strlen(ifname);
3541
3542 rcu_read_lock();
3543 list_for_each_entry_rcu(p, &t->if_list, list)
3544 if (strncmp(p->odevname, ifname, len) == 0) {
3545 if (p->odevname[len]) {
3546 if (exact || p->odevname[len] != '@')
3547 continue;
3548 }
3549 pkt_dev = p;
3550 break;
3551 }
3552
3553 rcu_read_unlock();
3554 pr_debug("find_dev(%s) returning %p\n", ifname, pkt_dev);
3555 return pkt_dev;
3556}
3557
3558
3559
3560
3561
3562static int add_dev_to_thread(struct pktgen_thread *t,
3563 struct pktgen_dev *pkt_dev)
3564{
3565 int rv = 0;
3566
3567
3568
3569
3570
3571
3572
3573 if_lock(t);
3574
3575 if (pkt_dev->pg_thread) {
3576 pr_err("ERROR: already assigned to a thread\n");
3577 rv = -EBUSY;
3578 goto out;
3579 }
3580
3581 pkt_dev->running = 0;
3582 pkt_dev->pg_thread = t;
3583 list_add_rcu(&pkt_dev->list, &t->if_list);
3584
3585out:
3586 if_unlock(t);
3587 return rv;
3588}
3589
3590
3591
3592static int pktgen_add_device(struct pktgen_thread *t, const char *ifname)
3593{
3594 struct pktgen_dev *pkt_dev;
3595 int err;
3596 int node = cpu_to_node(t->cpu);
3597
3598
3599
3600 pkt_dev = __pktgen_NN_threads(t->net, ifname, FIND);
3601 if (pkt_dev) {
3602 pr_err("ERROR: interface already used\n");
3603 return -EBUSY;
3604 }
3605
3606 pkt_dev = kzalloc_node(sizeof(struct pktgen_dev), GFP_KERNEL, node);
3607 if (!pkt_dev)
3608 return -ENOMEM;
3609
3610 strcpy(pkt_dev->odevname, ifname);
3611 pkt_dev->flows = vzalloc_node(array_size(MAX_CFLOWS,
3612 sizeof(struct flow_state)),
3613 node);
3614 if (pkt_dev->flows == NULL) {
3615 kfree(pkt_dev);
3616 return -ENOMEM;
3617 }
3618
3619 pkt_dev->removal_mark = 0;
3620 pkt_dev->nfrags = 0;
3621 pkt_dev->delay = pg_delay_d;
3622 pkt_dev->count = pg_count_d;
3623 pkt_dev->sofar = 0;
3624 pkt_dev->udp_src_min = 9;
3625 pkt_dev->udp_src_max = 9;
3626 pkt_dev->udp_dst_min = 9;
3627 pkt_dev->udp_dst_max = 9;
3628 pkt_dev->vlan_p = 0;
3629 pkt_dev->vlan_cfi = 0;
3630 pkt_dev->vlan_id = 0xffff;
3631 pkt_dev->svlan_p = 0;
3632 pkt_dev->svlan_cfi = 0;
3633 pkt_dev->svlan_id = 0xffff;
3634 pkt_dev->burst = 1;
3635 pkt_dev->node = NUMA_NO_NODE;
3636
3637 err = pktgen_setup_dev(t->net, pkt_dev, ifname);
3638 if (err)
3639 goto out1;
3640 if (pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)
3641 pkt_dev->clone_skb = pg_clone_skb_d;
3642
3643 pkt_dev->entry = proc_create_data(ifname, 0600, t->net->proc_dir,
3644 &pktgen_if_fops, pkt_dev);
3645 if (!pkt_dev->entry) {
3646 pr_err("cannot create %s/%s procfs entry\n",
3647 PG_PROC_DIR, ifname);
3648 err = -EINVAL;
3649 goto out2;
3650 }
3651#ifdef CONFIG_XFRM
3652 pkt_dev->ipsmode = XFRM_MODE_TRANSPORT;
3653 pkt_dev->ipsproto = IPPROTO_ESP;
3654
3655
3656
3657
3658
3659
3660 pkt_dev->dstops.family = AF_INET;
3661 pkt_dev->xdst.u.dst.dev = pkt_dev->odev;
3662 dst_init_metrics(&pkt_dev->xdst.u.dst, pktgen_dst_metrics, false);
3663 pkt_dev->xdst.child = &pkt_dev->xdst.u.dst;
3664 pkt_dev->xdst.u.dst.ops = &pkt_dev->dstops;
3665#endif
3666
3667 return add_dev_to_thread(t, pkt_dev);
3668out2:
3669 dev_put(pkt_dev->odev);
3670out1:
3671#ifdef CONFIG_XFRM
3672 free_SAs(pkt_dev);
3673#endif
3674 vfree(pkt_dev->flows);
3675 kfree(pkt_dev);
3676 return err;
3677}
3678
3679static int __net_init pktgen_create_thread(int cpu, struct pktgen_net *pn)
3680{
3681 struct pktgen_thread *t;
3682 struct proc_dir_entry *pe;
3683 struct task_struct *p;
3684
3685 t = kzalloc_node(sizeof(struct pktgen_thread), GFP_KERNEL,
3686 cpu_to_node(cpu));
3687 if (!t) {
3688 pr_err("ERROR: out of memory, can't create new thread\n");
3689 return -ENOMEM;
3690 }
3691
3692 mutex_init(&t->if_lock);
3693 t->cpu = cpu;
3694
3695 INIT_LIST_HEAD(&t->if_list);
3696
3697 list_add_tail(&t->th_list, &pn->pktgen_threads);
3698 init_completion(&t->start_done);
3699
3700 p = kthread_create_on_node(pktgen_thread_worker,
3701 t,
3702 cpu_to_node(cpu),
3703 "kpktgend_%d", cpu);
3704 if (IS_ERR(p)) {
3705 pr_err("kernel_thread() failed for cpu %d\n", t->cpu);
3706 list_del(&t->th_list);
3707 kfree(t);
3708 return PTR_ERR(p);
3709 }
3710 kthread_bind(p, cpu);
3711 t->tsk = p;
3712
3713 pe = proc_create_data(t->tsk->comm, 0600, pn->proc_dir,
3714 &pktgen_thread_fops, t);
3715 if (!pe) {
3716 pr_err("cannot create %s/%s procfs entry\n",
3717 PG_PROC_DIR, t->tsk->comm);
3718 kthread_stop(p);
3719 list_del(&t->th_list);
3720 kfree(t);
3721 return -EINVAL;
3722 }
3723
3724 t->net = pn;
3725 get_task_struct(p);
3726 wake_up_process(p);
3727 wait_for_completion(&t->start_done);
3728
3729 return 0;
3730}
3731
3732
3733
3734
3735static void _rem_dev_from_if_list(struct pktgen_thread *t,
3736 struct pktgen_dev *pkt_dev)
3737{
3738 struct list_head *q, *n;
3739 struct pktgen_dev *p;
3740
3741 if_lock(t);
3742 list_for_each_safe(q, n, &t->if_list) {
3743 p = list_entry(q, struct pktgen_dev, list);
3744 if (p == pkt_dev)
3745 list_del_rcu(&p->list);
3746 }
3747 if_unlock(t);
3748}
3749
3750static int pktgen_remove_device(struct pktgen_thread *t,
3751 struct pktgen_dev *pkt_dev)
3752{
3753 pr_debug("remove_device pkt_dev=%p\n", pkt_dev);
3754
3755 if (pkt_dev->running) {
3756 pr_warn("WARNING: trying to remove a running interface, stopping it now\n");
3757 pktgen_stop_device(pkt_dev);
3758 }
3759
3760
3761
3762 if (pkt_dev->odev) {
3763 dev_put(pkt_dev->odev);
3764 pkt_dev->odev = NULL;
3765 }
3766
3767
3768
3769
3770 proc_remove(pkt_dev->entry);
3771
3772
3773 _rem_dev_from_if_list(t, pkt_dev);
3774
3775#ifdef CONFIG_XFRM
3776 free_SAs(pkt_dev);
3777#endif
3778 vfree(pkt_dev->flows);
3779 if (pkt_dev->page)
3780 put_page(pkt_dev->page);
3781 kfree_rcu(pkt_dev, rcu);
3782 return 0;
3783}
3784
3785static int __net_init pg_net_init(struct net *net)
3786{
3787 struct pktgen_net *pn = net_generic(net, pg_net_id);
3788 struct proc_dir_entry *pe;
3789 int cpu, ret = 0;
3790
3791 pn->net = net;
3792 INIT_LIST_HEAD(&pn->pktgen_threads);
3793 pn->pktgen_exiting = false;
3794 pn->proc_dir = proc_mkdir(PG_PROC_DIR, pn->net->proc_net);
3795 if (!pn->proc_dir) {
3796 pr_warn("cannot create /proc/net/%s\n", PG_PROC_DIR);
3797 return -ENODEV;
3798 }
3799 pe = proc_create(PGCTRL, 0600, pn->proc_dir, &pktgen_fops);
3800 if (pe == NULL) {
3801 pr_err("cannot create %s procfs entry\n", PGCTRL);
3802 ret = -EINVAL;
3803 goto remove;
3804 }
3805
3806 for_each_online_cpu(cpu) {
3807 int err;
3808
3809 err = pktgen_create_thread(cpu, pn);
3810 if (err)
3811 pr_warn("Cannot create thread for cpu %d (%d)\n",
3812 cpu, err);
3813 }
3814
3815 if (list_empty(&pn->pktgen_threads)) {
3816 pr_err("Initialization failed for all threads\n");
3817 ret = -ENODEV;
3818 goto remove_entry;
3819 }
3820
3821 return 0;
3822
3823remove_entry:
3824 remove_proc_entry(PGCTRL, pn->proc_dir);
3825remove:
3826 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
3827 return ret;
3828}
3829
3830static void __net_exit pg_net_exit(struct net *net)
3831{
3832 struct pktgen_net *pn = net_generic(net, pg_net_id);
3833 struct pktgen_thread *t;
3834 struct list_head *q, *n;
3835 LIST_HEAD(list);
3836
3837
3838 pn->pktgen_exiting = true;
3839
3840 mutex_lock(&pktgen_thread_lock);
3841 list_splice_init(&pn->pktgen_threads, &list);
3842 mutex_unlock(&pktgen_thread_lock);
3843
3844 list_for_each_safe(q, n, &list) {
3845 t = list_entry(q, struct pktgen_thread, th_list);
3846 list_del(&t->th_list);
3847 kthread_stop(t->tsk);
3848 put_task_struct(t->tsk);
3849 kfree(t);
3850 }
3851
3852 remove_proc_entry(PGCTRL, pn->proc_dir);
3853 remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
3854}
3855
3856static struct pernet_operations pg_net_ops = {
3857 .init = pg_net_init,
3858 .exit = pg_net_exit,
3859 .id = &pg_net_id,
3860 .size = sizeof(struct pktgen_net),
3861};
3862
3863static int __init pg_init(void)
3864{
3865 int ret = 0;
3866
3867 pr_info("%s", version);
3868 ret = register_pernet_subsys(&pg_net_ops);
3869 if (ret)
3870 return ret;
3871 ret = register_netdevice_notifier(&pktgen_notifier_block);
3872 if (ret)
3873 unregister_pernet_subsys(&pg_net_ops);
3874
3875 return ret;
3876}
3877
3878static void __exit pg_cleanup(void)
3879{
3880 unregister_netdevice_notifier(&pktgen_notifier_block);
3881 unregister_pernet_subsys(&pg_net_ops);
3882
3883}
3884
3885module_init(pg_init);
3886module_exit(pg_cleanup);
3887
3888MODULE_AUTHOR("Robert Olsson <robert.olsson@its.uu.se>");
3889MODULE_DESCRIPTION("Packet Generator tool");
3890MODULE_LICENSE("GPL");
3891MODULE_VERSION(VERSION);
3892module_param(pg_count_d, int, 0);
3893MODULE_PARM_DESC(pg_count_d, "Default number of packets to inject");
3894module_param(pg_delay_d, int, 0);
3895MODULE_PARM_DESC(pg_delay_d, "Default delay between packets (nanoseconds)");
3896module_param(pg_clone_skb_d, int, 0);
3897MODULE_PARM_DESC(pg_clone_skb_d, "Default number of copies of the same packet");
3898module_param(debug, int, 0);
3899MODULE_PARM_DESC(debug, "Enable debugging of pktgen module");
3900