PageRenderTime 226ms CodeModel.GetById 21ms app.highlight 180ms RepoModel.GetById 1ms app.codeStats 1ms

/net/core/pktgen.c

http://github.com/mirrors/linux
C | 3896 lines | 2946 code | 619 blank | 331 comment | 595 complexity | c59dadde243d10df992a44b07ef85506 MD5 | raw file
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * Authors:
   4 * Copyright 2001, 2002 by Robert Olsson <robert.olsson@its.uu.se>
   5 *                             Uppsala University and
   6 *                             Swedish University of Agricultural Sciences
   7 *
   8 * Alexey Kuznetsov  <kuznet@ms2.inr.ac.ru>
   9 * Ben Greear <greearb@candelatech.com>
  10 * Jens Låås <jens.laas@data.slu.se>
  11 *
  12 * A tool for loading the network with preconfigurated packets.
  13 * The tool is implemented as a linux module.  Parameters are output
  14 * device, delay (to hard_xmit), number of packets, and whether
  15 * to use multiple SKBs or just the same one.
  16 * pktgen uses the installed interface's output routine.
  17 *
  18 * Additional hacking by:
  19 *
  20 * Jens.Laas@data.slu.se
  21 * Improved by ANK. 010120.
  22 * Improved by ANK even more. 010212.
  23 * MAC address typo fixed. 010417 --ro
  24 * Integrated.  020301 --DaveM
  25 * Added multiskb option 020301 --DaveM
  26 * Scaling of results. 020417--sigurdur@linpro.no
  27 * Significant re-work of the module:
  28 *   *  Convert to threaded model to more efficiently be able to transmit
  29 *       and receive on multiple interfaces at once.
  30 *   *  Converted many counters to __u64 to allow longer runs.
  31 *   *  Allow configuration of ranges, like min/max IP address, MACs,
  32 *       and UDP-ports, for both source and destination, and can
  33 *       set to use a random distribution or sequentially walk the range.
  34 *   *  Can now change most values after starting.
  35 *   *  Place 12-byte packet in UDP payload with magic number,
  36 *       sequence number, and timestamp.
  37 *   *  Add receiver code that detects dropped pkts, re-ordered pkts, and
  38 *       latencies (with micro-second) precision.
  39 *   *  Add IOCTL interface to easily get counters & configuration.
  40 *   --Ben Greear <greearb@candelatech.com>
  41 *
  42 * Renamed multiskb to clone_skb and cleaned up sending core for two distinct
  43 * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0
  44 * as a "fastpath" with a configurable number of clones after alloc's.
  45 * clone_skb=0 means all packets are allocated this also means ranges time
  46 * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100
  47 * clones.
  48 *
  49 * Also moved to /proc/net/pktgen/
  50 * --ro
  51 *
  52 * Sept 10:  Fixed threading/locking.  Lots of bone-headed and more clever
  53 *    mistakes.  Also merged in DaveM's patch in the -pre6 patch.
  54 * --Ben Greear <greearb@candelatech.com>
  55 *
  56 * Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br)
  57 *
  58 * 021124 Finished major redesign and rewrite for new functionality.
  59 * See Documentation/networking/pktgen.txt for how to use this.
  60 *
  61 * The new operation:
  62 * For each CPU one thread/process is created at start. This process checks
  63 * for running devices in the if_list and sends packets until count is 0 it
  64 * also the thread checks the thread->control which is used for inter-process
  65 * communication. controlling process "posts" operations to the threads this
  66 * way.
  67 * The if_list is RCU protected, and the if_lock remains to protect updating
  68 * of if_list, from "add_device" as it invoked from userspace (via proc write).
  69 *
  70 * By design there should only be *one* "controlling" process. In practice
  71 * multiple write accesses gives unpredictable result. Understood by "write"
  72 * to /proc gives result code thats should be read be the "writer".
  73 * For practical use this should be no problem.
  74 *
  75 * Note when adding devices to a specific CPU there good idea to also assign
  76 * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.
  77 * --ro
  78 *
  79 * Fix refcount off by one if first packet fails, potential null deref,
  80 * memleak 030710- KJP
  81 *
  82 * First "ranges" functionality for ipv6 030726 --ro
  83 *
  84 * Included flow support. 030802 ANK.
  85 *
  86 * Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org>
  87 *
  88 * Remove if fix from added Harald Welte <laforge@netfilter.org> 040419
  89 * ia64 compilation fix from  Aron Griffis <aron@hp.com> 040604
  90 *
  91 * New xmit() return, do_div and misc clean up by Stephen Hemminger
  92 * <shemminger@osdl.org> 040923
  93 *
  94 * Randy Dunlap fixed u64 printk compiler warning
  95 *
  96 * Remove FCS from BW calculation.  Lennert Buytenhek <buytenh@wantstofly.org>
  97 * New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213
  98 *
  99 * Corrections from Nikolai Malykh (nmalykh@bilim.com)
 100 * Removed unused flags F_SET_SRCMAC & F_SET_SRCIP 041230
 101 *
 102 * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com>
 103 * 050103
 104 *
 105 * MPLS support by Steven Whitehouse <steve@chygwyn.com>
 106 *
 107 * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com>
 108 *
 109 * Fixed src_mac command to set source mac of packet to value specified in
 110 * command by Adit Ranadive <adit.262@gmail.com>
 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>		/* do_div */
 173
 174#define VERSION	"2.75"
 175#define IP_NAME_SZ 32
 176#define MAX_MPLS_LABELS 16 /* This is the max label stack depth */
 177#define MPLS_STACK_BOTTOM htonl(0x00000100)
 178
 179#define func_enter() pr_debug("entering %s\n", __func__);
 180
 181#define PKT_FLAGS							\
 182	pf(IPV6)		/* Interface in IPV6 Mode */		\
 183	pf(IPSRC_RND)		/* IP-Src Random  */			\
 184	pf(IPDST_RND)		/* IP-Dst Random  */			\
 185	pf(TXSIZE_RND)		/* Transmit size is random */		\
 186	pf(UDPSRC_RND)		/* UDP-Src Random */			\
 187	pf(UDPDST_RND)		/* UDP-Dst Random */			\
 188	pf(UDPCSUM)		/* Include UDP checksum */		\
 189	pf(NO_TIMESTAMP)	/* Don't timestamp packets (default TS) */ \
 190	pf(MPLS_RND)		/* Random MPLS labels */		\
 191	pf(QUEUE_MAP_RND)	/* queue map Random */			\
 192	pf(QUEUE_MAP_CPU)	/* queue map mirrors smp_processor_id() */ \
 193	pf(FLOW_SEQ)		/* Sequential flows */			\
 194	pf(IPSEC)		/* ipsec on for flows */		\
 195	pf(MACSRC_RND)		/* MAC-Src Random */			\
 196	pf(MACDST_RND)		/* MAC-Dst Random */			\
 197	pf(VID_RND)		/* Random VLAN ID */			\
 198	pf(SVID_RND)		/* Random SVLAN ID */			\
 199	pf(NODE)		/* Node memory alloc*/			\
 200
 201#define pf(flag)		flag##_SHIFT,
 202enum pkt_flags {
 203	PKT_FLAGS
 204};
 205#undef pf
 206
 207/* Device flag bits */
 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/* Thread control flag bits */
 221#define T_STOP        (1<<0)	/* Stop run */
 222#define T_RUN         (1<<1)	/* Start run */
 223#define T_REMDEVALL   (1<<2)	/* Remove all devs */
 224#define T_REMDEV      (1<<3)	/* Remove one dev */
 225
 226/* Xmit modes */
 227#define M_START_XMIT		0	/* Default normal TX */
 228#define M_NETIF_RECEIVE 	1	/* Inject packets into stack */
 229#define M_QUEUE_XMIT		2	/* Inject packet into qdisc */
 230
 231/* If lock -- protects updating of if_list */
 232#define   if_lock(t)           mutex_lock(&(t->if_lock));
 233#define   if_unlock(t)           mutex_unlock(&(t->if_lock));
 234
 235/* Used to help with determining the pkts on receive */
 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/* flow flag bits */
 255#define F_INIT   (1<<0)		/* flow has been initialized */
 256
 257struct pktgen_dev {
 258	/*
 259	 * Try to keep frequent/infrequent used vars. separated.
 260	 */
 261	struct proc_dir_entry *entry;	/* proc file */
 262	struct pktgen_thread *pg_thread;/* the owner */
 263	struct list_head list;		/* chaining in the thread's run-queue */
 264	struct rcu_head	 rcu;		/* freed by RCU */
 265
 266	int running;		/* if false, the test will stop */
 267
 268	/* If min != max, then we will either do a linear iteration, or
 269	 * we will do a random selection from within the range.
 270	 */
 271	__u32 flags;
 272	int xmit_mode;
 273	int min_pkt_size;
 274	int max_pkt_size;
 275	int pkt_overhead;	/* overhead for MPLS, VLANs, IPSEC etc */
 276	int nfrags;
 277	int removal_mark;	/* non-zero => the device is marked for
 278				 * removal by worker thread */
 279
 280	struct page *page;
 281	u64 delay;		/* nano-seconds */
 282
 283	__u64 count;		/* Default No packets to send */
 284	__u64 sofar;		/* How many pkts we've sent so far */
 285	__u64 tx_bytes;		/* How many bytes we've transmitted */
 286	__u64 errors;		/* Errors when trying to transmit, */
 287
 288	/* runtime counters relating to clone_skb */
 289
 290	__u32 clone_count;
 291	int last_ok;		/* Was last skb sent?
 292				 * Or a failed transmit of some sort?
 293				 * This will keep sequence numbers in order
 294				 */
 295	ktime_t next_tx;
 296	ktime_t started_at;
 297	ktime_t stopped_at;
 298	u64	idle_acc;	/* nano-seconds */
 299
 300	__u32 seq_num;
 301
 302	int clone_skb;		/*
 303				 * Use multiple SKBs during packet gen.
 304				 * If this number is greater than 1, then
 305				 * that many copies of the same packet will be
 306				 * sent before a new packet is allocated.
 307				 * If you want to send 1024 identical packets
 308				 * before creating a new packet,
 309				 * set clone_skb to 1024.
 310				 */
 311
 312	char dst_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
 313	char dst_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
 314	char src_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
 315	char src_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
 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	/* For ranges */
 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	/* If we're doing ranges, random or incremental, then this
 328	 * defines the min/max for those ranges.
 329	 */
 330	__be32 saddr_min;	/* inclusive, source IP address */
 331	__be32 saddr_max;	/* exclusive, source IP address */
 332	__be32 daddr_min;	/* inclusive, dest IP address */
 333	__be32 daddr_max;	/* exclusive, dest IP address */
 334
 335	__u16 udp_src_min;	/* inclusive, source UDP port */
 336	__u16 udp_src_max;	/* exclusive, source UDP port */
 337	__u16 udp_dst_min;	/* inclusive, dest UDP port */
 338	__u16 udp_dst_max;	/* exclusive, dest UDP port */
 339
 340	/* DSCP + ECN */
 341	__u8 tos;            /* six MSB of (former) IPv4 TOS
 342				are for dscp codepoint */
 343	__u8 traffic_class;  /* ditto for the (former) Traffic Class in IPv6
 344				(see RFC 3260, sec. 4) */
 345
 346	/* MPLS */
 347	unsigned int nr_labels;	/* Depth of stack, 0 = no MPLS */
 348	__be32 labels[MAX_MPLS_LABELS];
 349
 350	/* VLAN/SVLAN (802.1Q/Q-in-Q) */
 351	__u8  vlan_p;
 352	__u8  vlan_cfi;
 353	__u16 vlan_id;  /* 0xffff means no vlan tag */
 354
 355	__u8  svlan_p;
 356	__u8  svlan_cfi;
 357	__u16 svlan_id; /* 0xffff means no svlan tag */
 358
 359	__u32 src_mac_count;	/* How many MACs to iterate through */
 360	__u32 dst_mac_count;	/* How many MACs to iterate through */
 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	   0x00, 0x80, 0xC8, 0x79, 0xB3, 0xCB,
 379
 380	   We fill in SRC address later
 381	   0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 382	   0x08, 0x00
 383	   };
 384	 */
 385	__u16 pad;		/* pad out the hh struct to an even 16 bytes */
 386
 387	struct sk_buff *skb;	/* skb we are to transmit next, used for when we
 388				 * are transmitting the same one multiple times
 389				 */
 390	struct net_device *odev; /* The out-going device.
 391				  * Note that the device should have it's
 392				  * pg_info pointer pointing back to this
 393				  * device.
 394				  * Set when the user specifies the out-going
 395				  * device name (not when the inject is
 396				  * started as it used to do.)
 397				  */
 398	char odevname[32];
 399	struct flow_state *flows;
 400	unsigned int cflows;	/* Concurrent flows (config) */
 401	unsigned int lflow;		/* Flow length  (config) */
 402	unsigned int nflows;	/* accumulated flows (stats) */
 403	unsigned int curfl;		/* current sequenced flow (state)*/
 404
 405	u16 queue_map_min;
 406	u16 queue_map_max;
 407	__u32 skb_priority;	/* skb priority field */
 408	unsigned int burst;	/* number of duplicated packets to burst */
 409	int node;               /* Memory node */
 410
 411#ifdef CONFIG_XFRM
 412	__u8	ipsmode;		/* IPSEC mode (config) */
 413	__u8	ipsproto;		/* IPSEC type (config) */
 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;		/* for list of devices */
 440	struct list_head if_list;	/* All device here */
 441	struct list_head th_list;
 442	struct task_struct *tsk;
 443	char result[512];
 444
 445	/* Field for thread to receive "posted" events terminate,
 446	   stop ifs etc. */
 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/* Module parameters, defaults. */
 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 * /proc handling functions
 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;	/* Strip trailing '\n' and terminate string */
 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 proc_ops pktgen_proc_ops = {
 539	.proc_open	= pgctrl_open,
 540	.proc_read	= seq_read,
 541	.proc_lseek	= seq_lseek,
 542	.proc_write	= pgctrl_write,
 543	.proc_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	/* not really stopped, more like last-running-at */
 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		/* allow only disabling ipv6 flag */
 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	/* Read variable name */
 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	/* Shortcut for min = max */
 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			/* clone_skb set earlier, not supported in this mode */
1187			if (pkt_dev->clone_skb > 0)
1188				return -ENOTSUPP;
1189
1190			pkt_dev->xmit_mode = M_NETIF_RECEIVE;
1191
1192			/* make sure new packet is allocated every time
1193			 * pktgen_xmit() is called
1194			 */
1195			pkt_dev->last_ok = 1;
1196
1197			/* override clone_skb if user passed default value
1198			 * at module loading time
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		/* Set up Dest MAC */
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		/* Set up Src MAC */
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; /* turn off VLAN/SVLAN */
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;  /* turn on VLAN */
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;    /* turn off MPLS */
1559			sprintf(pg_result, "OK: vlan_id=%u", pkt_dev->vlan_id);
1560		} else {
1561			pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
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;  /* turn on SVLAN */
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;    /* turn off MPLS */
1616			sprintf(pg_result, "OK: svlan_id=%u", pkt_dev->svlan_id);
1617		} else {
1618			pkt_dev->vlan_id = 0xffff; /* turn off VLAN/SVLAN */
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 proc_ops pktgen_if_proc_ops = {
1711	.proc_open	= pktgen_if_open,
1712	.proc_read	= seq_read,
1713	.proc_lseek	= seq_lseek,
1714	.proc_write	= pktgen_if_write,
1715	.proc_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		//      sprintf(pg_result, "Wrong command format");
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	/* Read variable name */
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));	/* Propagate thread->control  */
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 proc_ops pktgen_thread_proc_ops = {
1848	.proc_open	= pktgen_thread_open,
1849	.proc_read	= seq_read,
1850	.proc_lseek	= seq_lseek,
1851	.proc_write	= pktgen_thread_write,
1852	.proc_release	= single_release,
1853};
1854
1855/* Think find or remove for NN */
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 * mark a device for removal
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;	/* success */
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_proc_ops,
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	/* It is OK that we do not hold the group lock right now,
1951	 * as we run under the RTNL lock.
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/* Associate pktgen_dev with a device. */
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	/* Clean old setups */
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 && odev->type != ARPHRD_LOOPBACK) {
2007		pr_err("not an ethernet or loopback 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/* Read pkt_dev from the interface and set up internal pktgen_dev
2022 * structure to have the right information to create/send packets
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	/* make sure that we don't pick a non-existing transmit queue */
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	/* Default to the interface's mac if not explicitly set. */
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	/* Set up Dest MAC */
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			 * Use linklevel address if unconfigured.
2080			 *
2081			 * use ipv6_get_lladdr if/when it's get exported
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	/* Initialize current values. */
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_sleeper_on_stack(&t, 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		/* for small delays (<100us), just loop until limit is reached */
2169		do {
2170			end_time = ktime_get();
2171		} while (ktime_compare(end_time, spin_until) < 0);
2172	} else {
2173		do {
2174			set_current_state(TASK_INTERRUPTIBLE);
2175			hrtimer_sleeper_start_expires(&t, HRTIMER_MODE_ABS);
2176
2177			if (likely(t.task))
2178				schedule();
2179
2180			hrtimer_cancel(&t.timer);
2181		} while (t.task && pkt_dev->running && !signal_pending(current));
2182		__set_current_state(TASK_RUNNING);
2183		end_time = ktime_get();
2184	}
2185
2186	pkt_dev->idle_acc += ktime_to_ns(ktime_sub(end_time, start_time));
2187out:
2188	pkt_dev->next_tx = ktime_add_ns(spin_until, pkt_dev->delay);
2189	destroy_hrtimer_on_stack(&t.timer);
2190}
2191
2192static inline void set_pkt_overhead(struct pktgen_dev *pkt_dev)
2193{
2194	pkt_dev->pkt_overhead = 0;
2195	pkt_dev->pkt_overhead += pkt_dev->nr_labels*sizeof(u32);
2196	pkt_dev->pkt_overhead += VLAN_TAG_SIZE(pkt_dev);
2197	pkt_dev->pkt_overhead += SVLAN_TAG_SIZE(pkt_dev);
2198}
2199
2200static inline int f_seen(const struct pktgen_dev *pkt_dev, int flow)
2201{
2202	return !!(pkt_dev->flows[flow].flags & F_INIT);
2203}
2204
2205static inline int f_pick(struct pktgen_dev *pkt_dev)
2206{
2207	int flow = pkt_dev->curfl;
2208
2209	if (pkt_dev->flags & F_FLOW_SEQ) {
2210		if (pkt_dev->flows[flow].count >= pkt_dev->lflow) {
2211			/* reset time */
2212			pkt_dev->flows[flow].count = 0;
2213			pkt_dev->flows[flow].flags = 0;
2214			pkt_dev->curfl += 1;
2215			if (pkt_dev->curfl >= pkt_dev->cflows)
2216				pkt_dev->curfl = 0; /*reset */
2217		}
2218	} else {
2219		flow = prandom_u32() % pkt_dev->cflows;
2220		pkt_dev->curfl = flow;
2221
2222		if (pkt_dev->flows[flow].count > pkt_dev->lflow) {
2223			pkt_dev->flows[flow].count = 0;
2224			pkt_dev->flows[flow].flags = 0;
2225		}
2226	}
2227
2228	return pkt_dev->curfl;
2229}
2230
2231
2232#ifdef CONFIG_XFRM
2233/* If there was already an IPSEC SA, we keep it as is, else
2234 * we go look for it ...
2235*/
2236#define DUMMY_MARK 0
2237static void get_ipsec_sa(struct pktgen_dev *pkt_dev, int flow)
2238{
2239	struct xfrm_state *x = pkt_dev->flows[flow].x;
2240	struct pktgen_net *pn = net_generic(dev_net(pkt_dev->odev), pg_net_id);
2241	if (!x) {
2242
2243		if (pkt_dev->spi) {
2244			/* We need as quick as possible to find the right SA
2245			 * Searching with minimum criteria to archieve this.
2246			 */
2247			x = xfrm_state_lookup_byspi(pn->net, htonl(pkt_dev->spi), AF_INET);
2248		} else {
2249			/* slow path: we dont already have xfrm_state */
2250			x = xfrm_stateonly_find(pn->net, DUMMY_MARK, 0,
2251						(xfrm_address_t *)&pkt_dev->cur_daddr,
2252						(xfrm_address_t *)&pkt_dev->cur_saddr,
2253						AF_INET,
2254						pkt_dev->ipsmode,
2255						pkt_dev->ipsproto, 0);
2256		}
2257		if (x) {
2258			pkt_dev->flows[flow].x = x;
2259			set_pkt_overhead(pkt_dev);
2260			pkt_dev->pkt_overhead += x->props.header_len;
2261		}
2262
2263	}
2264}
2265#endif
2266static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
2267{
2268
2269	if (pkt_dev->flags & F_QUEUE_MAP_CPU)
2270		pkt_dev->cur_queue_map = smp_processor_id();
2271
2272	else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
2273		__u16 t;
2274		if (pkt_dev->flags & F_QUEUE_MAP_RND) {
2275			t = prandom_u32() %
2276				(pkt_dev->queue_map_max -
2277				 pkt_dev->queue_map_min + 1)
2278				+ pkt_dev->queue_map_min;
2279		} else {
2280			t = pkt_dev->cur_queue_map + 1;
2281			if (t > pkt_dev->queue_map_max)
2282				t = pkt_dev->queue_map_min;
2283		}
2284		pkt_dev->cur_queue_map = t;
2285	}
2286	pkt_dev->cur_queue_map  = pkt_dev->cur_queue_map % pkt_dev->odev->real_num_tx_queues;
2287}
2288
2289/* Increment/randomize headers according to flags and current values
2290 * for IP src/dest, UDP src/dst port, MAC-Addr src/dst
2291 */
2292static void mod_cur_headers(struct pktgen_dev *pkt_dev)
2293{
2294	__u32 imn;
2295	__u32 imx;
2296	int flow = 0;
2297
2298	if (pkt_dev->cflows)
2299		flow = f_pick(pkt_dev);
2300
2301	/*  Deal with source MAC */
2302	if (pkt_dev->src_mac_count > 1) {
2303		__u32 mc;
2304		__u32 tmp;
2305
2306		if (pkt_dev->flags & F_MACSRC_RND)
2307			mc = prandom_u32() % pkt_dev->src_mac_count;
2308		else {
2309			mc = pkt_dev->cur_src_mac_offset++;
2310			if (pkt_dev->cur_src_mac_offset >=
2311			    pkt_dev->src_mac_count)
2312				pkt_dev->cur_src_mac_offset = 0;
2313		}
2314
2315		tmp = pkt_dev->src_mac[5] + (mc & 0xFF);
2316		pkt_dev->hh[11] = tmp;
2317		tmp = (pkt_dev->src_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2318		pkt_dev->hh[10] = tmp;
2319		tmp = (pkt_dev->src_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2320		pkt_dev->hh[9] = tmp;
2321		tmp = (pkt_dev->src_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2322		pkt_dev->hh[8] = tmp;
2323		tmp = (pkt_dev->src_mac[1] + (tmp >> 8));
2324		pkt_dev->hh[7] = tmp;
2325	}
2326
2327	/*  Deal with Destination MAC */
2328	if (pkt_dev->dst_mac_count > 1) {
2329		__u32 mc;
2330		__u32 tmp;
2331
2332		if (pkt_dev->flags & F_MACDST_RND)
2333			mc = prandom_u32() % pkt_dev->dst_mac_count;
2334
2335		else {
2336			mc = pkt_dev->cur_dst_mac_offset++;
2337			if (pkt_dev->cur_dst_mac_offset >=
2338			    pkt_dev->dst_mac_count) {
2339				pkt_dev->cur_dst_mac_offset = 0;
2340			}
2341		}
2342
2343		tmp = pkt_dev->dst_mac[5] + (mc & 0xFF);
2344		pkt_dev->hh[5] = tmp;
2345		tmp = (pkt_dev->dst_mac[4] + ((mc >> 8) & 0xFF) + (tmp >> 8));
2346		pkt_dev->hh[4] = tmp;
2347		tmp = (pkt_dev->dst_mac[3] + ((mc >> 16) & 0xFF) + (tmp >> 8));
2348		pkt_dev->hh[3] = tmp;
2349		tmp = (pkt_dev->dst_mac[2] + ((mc >> 24) & 0xFF) + (tmp >> 8));
2350		pkt_dev->hh[2] = tmp;
2351		tmp = (pkt_dev->dst_mac[1] + (tmp >> 8));
2352		pkt_dev->hh[1] = tmp;
2353	}
2354
2355	if (pkt_dev->flags & F_MPLS_RND) {
2356		unsigned int i;
2357		for (i = 0; i < pkt_dev->nr_labels; i++)
2358			if (pkt_dev->labels[i] & MPLS_STACK_BOTTOM)
2359				pkt_dev->labels[i] = MPLS_STACK_BOTTOM |
2360					     ((__force __be32)prandom_u32() &
2361						      htonl(0x000fffff));
2362	}
2363
2364	if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
2365		pkt_dev->vlan_id = prandom_u32() & (4096 - 1);
2366	}
2367
2368	if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
2369		pkt_dev->svlan_id = prandom_u32() & (4096 - 1);
2370	}
2371
2372	if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
2373		if (pkt_dev->flags & F_UDPSRC_RND)
2374			pkt_dev->cur_udp_src = prandom_u32() %
2375				(pkt_dev->udp_src_max - pkt_dev->udp_src_min)
2376				+ pkt_dev->udp_src_min;
2377
2378		else {
2379			pkt_dev->cur_udp_src++;
2380			if (pkt_dev->cur_udp_src >= pkt_dev->udp_src_max)
2381				pkt_dev->cur_udp_src = pkt_dev->udp_src_min;
2382		}
2383	}
2384
2385	if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
2386		if (pkt_dev->flags & F_UDPDST_RND) {
2387			pkt_dev->cur_udp_dst = prandom_u32() %
2388				(pkt_dev->udp_dst_max - pkt_dev->udp_dst_min)
2389				+ pkt_dev->udp_dst_min;
2390		} else {
2391			pkt_dev->cur_udp_dst++;
2392			if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
2393				pkt_dev->cur_udp_dst = pkt_dev->udp_dst_min;
2394		}
2395	}
2396
2397	if (!(pkt_dev->flags & F_IPV6)) {
2398
2399		imn = ntohl(pkt_dev->saddr_min);
2400		imx = ntohl(pkt_dev->saddr_max);
2401		if (imn < imx) {
2402			__u32 t;
2403			if (pkt_dev->flags & F_IPSRC_RND)
2404				t = prandom_u32() % (imx - imn) + imn;
2405			else {
2406				t = ntohl(pkt_dev->cur_saddr);
2407				t++;
2408				if (t > imx)
2409					t = imn;
2410
2411			}
2412			pkt_dev->cur_saddr = htonl(t);
2413		}
2414
2415		if (pkt_dev->cflows && f_seen(pkt_dev, flow)) {
2416			pkt_dev->cur_daddr = pkt_dev->flows[flow].cur_daddr;
2417		} else {
2418			imn = ntohl(pkt_dev->daddr_min);
2419			imx = ntohl(pkt_dev->daddr_max);
2420			if (imn < imx) {
2421				__u32 t;
2422				__be32 s;
2423				if (pkt_dev->flags & F_IPDST_RND) {
2424
2425					do {
2426						t = prandom_u32() %
2427							(imx - imn) + imn;
2428						s = htonl(t);
2429					} while (ipv4_is_loopback(s) ||
2430						ipv4_is_multicast(s) ||
2431						ipv4_is_lbcast(s) ||
2432						ipv4_is_zeronet(s) ||
2433						ipv4_is_local_multicast(s));
2434					pkt_dev->cur_daddr = s;
2435				} else {
2436					t = ntohl(pkt_dev->cur_daddr);
2437					t++;
2438					if (t > imx) {
2439						t = imn;
2440					}
2441					pkt_dev->cur_daddr = htonl(t);
2442				}
2443			}
2444			if (pkt_dev->cflows) {
2445				pkt_dev->flows[flow].flags |= F_INIT;
2446				pkt_dev->flows[flow].cur_daddr =
2447				    pkt_dev->cur_daddr;
2448#ifdef CONFIG_XFRM
2449				if (pkt_dev->flags & F_IPSEC)
2450					get_ipsec_sa(pkt_dev, flow);
2451#endif
2452				pkt_dev->nflows++;
2453			}
2454		}
2455	} else {		/* IPV6 * */
2456
2457		if (!ipv6_addr_any(&pkt_dev->min_in6_daddr)) {
2458			int i;
2459
2460			/* Only random destinations yet */
2461
2462			for (i = 0; i < 4; i++) {
2463				pkt_dev->cur_in6_daddr.s6_addr32[i] =
2464				    (((__force __be32)prandom_u32() |
2465				      pkt_dev->min_in6_daddr.s6_addr32[i]) &
2466				     pkt_dev->max_in6_daddr.s6_addr32[i]);
2467			}
2468		}
2469	}
2470
2471	if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
2472		__u32 t;
2473		if (pkt_dev->flags & F_TXSIZE_RND) {
2474			t = prandom_u32() %
2475				(pkt_dev->max_pkt_size - pkt_dev->min_pkt_size)
2476				+ pkt_dev->min_pkt_size;
2477		} else {
2478			t = pkt_dev->cur_pkt_size + 1;
2479			if (t > pkt_dev->max_pkt_size)
2480				t = pkt_dev->min_pkt_size;
2481		}
2482		pkt_dev->cur_pkt_size = t;
2483	}
2484
2485	set_cur_queue_map(pkt_dev);
2486
2487	pkt_dev->flows[flow].count++;
2488}
2489
2490
2491#ifdef CONFIG_XFRM
2492static u32 pktgen_dst_metrics[RTAX_MAX + 1] = {
2493
2494	[RTAX_HOPLIMIT] = 0x5, /* Set a static hoplimit */
2495};
2496
2497static int pktgen_output_ipsec(struct sk_buff *skb, struct pktgen_dev *pkt_dev)
2498{
2499	struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2500	int err = 0;
2501	struct net *net = dev_net(pkt_dev->odev);
2502
2503	if (!x)
2504		return 0;
2505	/* XXX: we dont support tunnel mode for now until
2506	 * we resolve the dst issue */
2507	if ((x->props.mode != XFRM_MODE_TRANSPORT) && (pkt_dev->spi == 0))
2508		return 0;
2509
2510	/* But when user specify an valid SPI, transformation
2511	 * supports both transport/tunnel mode + ESP/AH type.
2512	 */
2513	if ((x->props.mode == XFRM_MODE_TUNNEL) && (pkt_dev->spi != 0))
2514		skb->_skb_refdst = (unsigned long)&pkt_dev->xdst.u.dst | SKB_DST_NOREF;
2515
2516	rcu_read_lock_bh();
2517	err = pktgen_xfrm_outer_mode_output(x, skb);
2518	rcu_read_unlock_bh();
2519	if (err) {
2520		XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEMODEERROR);
2521		goto error;
2522	}
2523	err = x->type->output(x, skb);
2524	if (err) {
2525		XFRM_INC_STATS(net, LINUX_MIB_XFRMOUTSTATEPROTOERROR);
2526		goto error;
2527	}
2528	spin_lock_bh(&x->lock);
2529	x->curlft.bytes += skb->len;
2530	x->curlft.packets++;
2531	spin_unlock_bh(&x->lock);
2532error:
2533	return err;
2534}
2535
2536static void free_SAs(struct pktgen_dev *pkt_dev)
2537{
2538	if (pkt_dev->cflows) {
2539		/* let go of the SAs if we have them */
2540		int i;
2541		for (i = 0; i < pkt_dev->cflows; i++) {
2542			struct xfrm_state *x = pkt_dev->flows[i].x;
2543			if (x) {
2544				xfrm_state_put(x);
2545				pkt_dev->flows[i].x = NULL;
2546			}
2547		}
2548	}
2549}
2550
2551static int process_ipsec(struct pktgen_dev *pkt_dev,
2552			      struct sk_buff *skb, __be16 protocol)
2553{
2554	if (pkt_dev->flags & F_IPSEC) {
2555		struct xfrm_state *x = pkt_dev->flows[pkt_dev->curfl].x;
2556		int nhead = 0;
2557		if (x) {
2558			struct ethhdr *eth;
2559			struct iphdr *iph;
2560			int ret;
2561
2562			nhead = x->props.header_len - skb_headroom(skb);
2563			if (nhead > 0) {
2564				ret = pskb_expand_head(skb, nhead, 0, GFP_ATOMIC);
2565				if (ret < 0) {
2566					pr_err("Error expanding ipsec packet %d\n",
2567					       ret);
2568					goto err;
2569				}
2570			}
2571
2572			/* ipsec is not expecting ll header */
2573			skb_pull(skb, ETH_HLEN);
2574			ret = pktgen_output_ipsec(skb, pkt_dev);
2575			if (ret) {
2576				pr_err("Error creating ipsec packet %d\n", ret);
2577				goto err;
2578			}
2579			/* restore ll */
2580			eth = skb_push(skb, ETH_HLEN);
2581			memcpy(eth, pkt_dev->hh, 2 * ETH_ALEN);
2582			eth->h_proto = protocol;
2583
2584			/* Update IPv4 header len as well as checksum value */
2585			iph = ip_hdr(skb);
2586			iph->tot_len = htons(skb->len - ETH_HLEN);
2587			ip_send_check(iph);
2588		}
2589	}
2590	return 1;
2591err:
2592	kfree_skb(skb);
2593	return 0;
2594}
2595#endif
2596
2597static void mpls_push(__be32 *mpls, struct pktgen_dev *pkt_dev)
2598{
2599	unsigned int i;
2600	for (i = 0; i < pkt_dev->nr_labels; i++)
2601		*mpls++ = pkt_dev->labels[i] & ~MPLS_STACK_BOTTOM;
2602
2603	mpls--;
2604	*mpls |= MPLS_STACK_BOTTOM;
2605}
2606
2607static inline __be16 build_tci(unsigned int id, unsigned int cfi,
2608			       unsigned int prio)
2609{
2610	return htons(id | (cfi << 12) | (prio << 13));
2611}
2612
2613static void pktgen_finalize_skb(struct pktgen_dev *pkt_dev, struct sk_buff *skb,
2614				int datalen)
2615{
2616	struct timespec64 timestamp;
2617	struct pktgen_hdr *pgh;
2618
2619	pgh = skb_put(skb, sizeof(*pgh));
2620	datalen -= sizeof(*pgh);
2621
2622	if (pkt_dev->nfrags <= 0) {
2623		skb_put_zero(skb, datalen);
2624	} else {
2625		int frags = pkt_dev->nfrags;
2626		int i, len;
2627		int frag_len;
2628
2629
2630		if (frags > MAX_SKB_FRAGS)
2631			frags = MAX_SKB_FRAGS;
2632		len = datalen - frags * PAGE_SIZE;
2633		if (len > 0) {
2634			skb_put_zero(skb, len);
2635			datalen = frags * PAGE_SIZE;
2636		}
2637
2638		i = 0;
2639		frag_len = (datalen/frags) < PAGE_SIZE ?
2640			   (datalen/frags) : PAGE_SIZE;
2641		while (datalen > 0) {
2642			if (unlikely(!pkt_dev->page)) {
2643				int node = numa_node_id();
2644
2645				if (pkt_dev->node >= 0 && (pkt_dev->flags & F_NODE))
2646					node = pkt_dev->node;
2647				pkt_dev->page = alloc_pages_node(node, GFP_KERNEL | __GFP_ZERO, 0);
2648				if (!pkt_dev->page)
2649					break;
2650			}
2651			get_page(pkt_dev->page);
2652			skb_frag_set_page(skb, i, pkt_dev->page);
2653			skb_frag_off_set(&skb_shinfo(skb)->frags[i], 0);
2654			/*last fragment, fill rest of data*/
2655			if (i == (frags - 1))
2656				skb_frag_size_set(&skb_shinfo(skb)->frags[i],
2657				    (datalen < PAGE_SIZE ? datalen : PAGE_SIZE));
2658			else
2659				skb_frag_size_set(&skb_shinfo(skb)->frags[i], frag_len);
2660			datalen -= skb_frag_size(&skb_shinfo(skb)->frags[i]);
2661			skb->len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2662			skb->data_len += skb_frag_size(&skb_shinfo(skb)->frags[i]);
2663			i++;
2664			skb_shinfo(skb)->nr_frags = i;
2665		}
2666	}
2667
2668	/* Stamp the time, and sequence number,
2669	 * convert them to network byte order
2670	 */
2671	pgh->pgh_magic = htonl(PKTGEN_MAGIC);
2672	pgh->seq_num = htonl(pkt_dev->seq_num);
2673
2674	if (pkt_dev->flags & F_NO_TIMESTAMP) {
2675		pgh->tv_sec = 0;
2676		pgh->tv_usec = 0;
2677	} else {
2678		/*
2679		 * pgh->tv_sec wraps in y2106 when interpreted as unsigned
2680		 * as done by wireshark, or y2038 when interpreted as signed.
2681		 * This is probably harmless, but if anyone wants to improve
2682		 * it, we could introduce a variant that puts 64-bit nanoseconds
2683		 * into the respective header bytes.
2684		 * This would also be slightly faster to read.
2685		 */
2686		ktime_get_real_ts64(&timestamp);
2687		pgh->tv_sec = htonl(timestamp.tv_sec);
2688		pgh->tv_usec = htonl(timestamp.tv_nsec / NSEC_PER_USEC);
2689	}
2690}
2691
2692static struct sk_buff *pktgen_alloc_skb(struct net_device *dev,
2693					struct pktgen_dev *pkt_dev)
2694{
2695	unsigned int extralen = LL_RESERVED_SPACE(dev);
2696	struct sk_buff *skb = NULL;
2697	unsigned int size;
2698
2699	size = pkt_dev->cur_pkt_size + 64 + extralen + pkt_dev->pkt_overhead;
2700	if (pkt_dev->flags & F_NODE) {
2701		int node = pkt_dev->node >= 0 ? pkt_dev->node : numa_node_id();
2702
2703		skb = __alloc_skb(NET_SKB_PAD + size, GFP_NOWAIT, 0, node);
2704		if (likely(skb)) {
2705			skb_reserve(skb, NET_SKB_PAD);
2706			skb->dev = dev;
2707		}
2708	} else {
2709		 skb = __netdev_alloc_skb(dev, size, GFP_NOWAIT);
2710	}
2711
2712	/* the caller pre-fetches from skb->data and reserves for the mac hdr */
2713	if (likely(skb))
2714		skb_reserve(skb, extralen - 16);
2715
2716	return skb;
2717}
2718
2719static struct sk_buff *fill_packet_ipv4(struct net_device *odev,
2720					struct pktgen_dev *pkt_dev)
2721{
2722	struct sk_buff *skb = NULL;
2723	__u8 *eth;
2724	struct udphdr *udph;
2725	int datalen, iplen;
2726	struct iphdr *iph;
2727	__be16 protocol = htons(ETH_P_IP);
2728	__be32 *mpls;
2729	__be16 *vlan_tci = NULL;                 /* Encapsulates priority and VLAN ID */
2730	__be16 *vlan_encapsulated_proto = NULL;  /* packet type ID field (or len) for VLAN tag */
2731	__be16 *svlan_tci = NULL;                /* Encapsulates priority and SVLAN ID */
2732	__be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
2733	u16 queue_map;
2734
2735	if (pkt_dev->nr_labels)
2736		protocol = htons(ETH_P_MPLS_UC);
2737
2738	if (pkt_dev->vlan_id != 0xffff)
2739		protocol = htons(ETH_P_8021Q);
2740
2741	/* Update any of the values, used when we're incrementing various
2742	 * fields.
2743	 */
2744	mod_cur_headers(pkt_dev);
2745	queue_map = pkt_dev->cur_queue_map;
2746
2747	skb = pktgen_alloc_skb(odev, pkt_dev);
2748	if (!skb) {
2749		sprintf(pkt_dev->result, "No memory");
2750		return NULL;
2751	}
2752
2753	prefetchw(skb->data);
2754	skb_reserve(skb, 16);
2755
2756	/*  Reserve for ethernet and IP header  */
2757	eth = skb_push(skb, 14);
2758	mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2759	if (pkt_dev->nr_labels)
2760		mpls_push(mpls, pkt_dev);
2761
2762	if (pkt_dev->vlan_id != 0xffff) {
2763		if (pkt_dev->svlan_id != 0xffff) {
2764			svlan_tci = skb_put(skb, sizeof(__be16));
2765			*svlan_tci = build_tci(pkt_dev->svlan_id,
2766					       pkt_dev->svlan_cfi,
2767					       pkt_dev->svlan_p);
2768			svlan_encapsulated_proto = skb_put(skb,
2769							   sizeof(__be16));
2770			*svlan_encapsulated_proto = htons(ETH_P_8021Q);
2771		}
2772		vlan_tci = skb_put(skb, sizeof(__be16));
2773		*vlan_tci = build_tci(pkt_dev->vlan_id,
2774				      pkt_dev->vlan_cfi,
2775				      pkt_dev->vlan_p);
2776		vlan_encapsulated_proto = skb_put(skb, sizeof(__be16));
2777		*vlan_encapsulated_proto = htons(ETH_P_IP);
2778	}
2779
2780	skb_reset_mac_header(skb);
2781	skb_set_network_header(skb, skb->len);
2782	iph = skb_put(skb, sizeof(struct iphdr));
2783
2784	skb_set_transport_header(skb, skb->len);
2785	udph = skb_put(skb, sizeof(struct udphdr));
2786	skb_set_queue_mapping(skb, queue_map);
2787	skb->priority = pkt_dev->skb_priority;
2788
2789	memcpy(eth, pkt_dev->hh, 12);
2790	*(__be16 *) & eth[12] = protocol;
2791
2792	/* Eth + IPh + UDPh + mpls */
2793	datalen = pkt_dev->cur_pkt_size - 14 - 20 - 8 -
2794		  pkt_dev->pkt_overhead;
2795	if (datalen < 0 || datalen < sizeof(struct pktgen_hdr))
2796		datalen = sizeof(struct pktgen_hdr);
2797
2798	udph->source = htons(pkt_dev->cur_udp_src);
2799	udph->dest = htons(pkt_dev->cur_udp_dst);
2800	udph->len = htons(datalen + 8);	/* DATA + udphdr */
2801	udph->check = 0;
2802
2803	iph->ihl = 5;
2804	iph->version = 4;
2805	iph->ttl = 32;
2806	iph->tos = pkt_dev->tos;
2807	iph->protocol = IPPROTO_UDP;	/* UDP */
2808	iph->saddr = pkt_dev->cur_saddr;
2809	iph->daddr = pkt_dev->cur_daddr;
2810	iph->id = htons(pkt_dev->ip_id);
2811	pkt_dev->ip_id++;
2812	iph->frag_off = 0;
2813	iplen = 20 + 8 + datalen;
2814	iph->tot_len = htons(iplen);
2815	ip_send_check(iph);
2816	skb->protocol = protocol;
2817	skb->dev = odev;
2818	skb->pkt_type = PACKET_HOST;
2819
2820	pktgen_finalize_skb(pkt_dev, skb, datalen);
2821
2822	if (!(pkt_dev->flags & F_UDPCSUM)) {
2823		skb->ip_summed = CHECKSUM_NONE;
2824	} else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IP_CSUM)) {
2825		skb->ip_summed = CHECKSUM_PARTIAL;
2826		skb->csum = 0;
2827		udp4_hwcsum(skb, iph->saddr, iph->daddr);
2828	} else {
2829		__wsum csum = skb_checksum(skb, skb_transport_offset(skb), datalen + 8, 0);
2830
2831		/* add protocol-dependent pseudo-header */
2832		udph->check = csum_tcpudp_magic(iph->saddr, iph->daddr,
2833						datalen + 8, IPPROTO_UDP, csum);
2834
2835		if (udph->check == 0)
2836			udph->check = CSUM_MANGLED_0;
2837	}
2838
2839#ifdef CONFIG_XFRM
2840	if (!process_ipsec(pkt_dev, skb, protocol))
2841		return NULL;
2842#endif
2843
2844	return skb;
2845}
2846
2847static struct sk_buff *fill_packet_ipv6(struct net_device *odev,
2848					struct pktgen_dev *pkt_dev)
2849{
2850	struct sk_buff *skb = NULL;
2851	__u8 *eth;
2852	struct udphdr *udph;
2853	int datalen, udplen;
2854	struct ipv6hdr *iph;
2855	__be16 protocol = htons(ETH_P_IPV6);
2856	__be32 *mpls;
2857	__be16 *vlan_tci = NULL;                 /* Encapsulates priority and VLAN ID */
2858	__be16 *vlan_encapsulated_proto = NULL;  /* packet type ID field (or len) for VLAN tag */
2859	__be16 *svlan_tci = NULL;                /* Encapsulates priority and SVLAN ID */
2860	__be16 *svlan_encapsulated_proto = NULL; /* packet type ID field (or len) for SVLAN tag */
2861	u16 queue_map;
2862
2863	if (pkt_dev->nr_labels)
2864		protocol = htons(ETH_P_MPLS_UC);
2865
2866	if (pkt_dev->vlan_id != 0xffff)
2867		protocol = htons(ETH_P_8021Q);
2868
2869	/* Update any of the values, used when we're incrementing various
2870	 * fields.
2871	 */
2872	mod_cur_headers(pkt_dev);
2873	queue_map = pkt_dev->cur_queue_map;
2874
2875	skb = pktgen_alloc_skb(odev, pkt_dev);
2876	if (!skb) {
2877		sprintf(pkt_dev->result, "No memory");
2878		return NULL;
2879	}
2880
2881	prefetchw(skb->data);
2882	skb_reserve(skb, 16);
2883
2884	/*  Reserve for ethernet and IP header  */
2885	eth = skb_push(skb, 14);
2886	mpls = skb_put(skb, pkt_dev->nr_labels * sizeof(__u32));
2887	if (pkt_dev->nr_labels)
2888		mpls_push(mpls, pkt_dev);
2889
2890	if (pkt_dev->vlan_id != 0xffff) {
2891		if (pkt_dev->svlan_id != 0xffff) {
2892			svlan_tci = skb_put(skb, sizeof(__be16));
2893			*svlan_tci = build_tci(pkt_dev->svlan_id,
2894					       pkt_dev->svlan_cfi,
2895					       pkt_dev->svlan_p);
2896			svlan_encapsulated_proto = skb_put(skb,
2897							   sizeof(__be16));
2898			*svlan_encapsulated_proto = htons(ETH_P_8021Q);
2899		}
2900		vlan_tci = skb_put(skb, sizeof(__be16));
2901		*vlan_tci = build_tci(pkt_dev->vlan_id,
2902				      pkt_dev->vlan_cfi,
2903				      pkt_dev->vlan_p);
2904		vlan_encapsulated_proto = skb_put(skb, sizeof(__be16));
2905		*vlan_encapsulated_proto = htons(ETH_P_IPV6);
2906	}
2907
2908	skb_reset_mac_header(skb);
2909	skb_set_network_header(skb, skb->len);
2910	iph = skb_put(skb, sizeof(struct ipv6hdr));
2911
2912	skb_set_transport_header(skb, skb->len);
2913	udph = skb_put(skb, sizeof(struct udphdr));
2914	skb_set_queue_mapping(skb, queue_map);
2915	skb->priority = pkt_dev->skb_priority;
2916
2917	memcpy(eth, pkt_dev->hh, 12);
2918	*(__be16 *) &eth[12] = protocol;
2919
2920	/* Eth + IPh + UDPh + mpls */
2921	datalen = pkt_dev->cur_pkt_size - 14 -
2922		  sizeof(struct ipv6hdr) - sizeof(struct udphdr) -
2923		  pkt_dev->pkt_overhead;
2924
2925	if (datalen < 0 || datalen < sizeof(struct pktgen_hdr)) {
2926		datalen = sizeof(struct pktgen_hdr);
2927		net_info_ratelimited("increased datalen to %d\n", datalen);
2928	}
2929
2930	udplen = datalen + sizeof(struct udphdr);
2931	udph->source = htons(pkt_dev->cur_udp_src);
2932	udph->dest = htons(pkt_dev->cur_udp_dst);
2933	udph->len = htons(udplen);
2934	udph->check = 0;
2935
2936	*(__be32 *) iph = htonl(0x60000000);	/* Version + flow */
2937
2938	if (pkt_dev->traffic_class) {
2939		/* Version + traffic class + flow (0) */
2940		*(__be32 *)iph |= htonl(0x60000000 | (pkt_dev->traffic_class << 20));
2941	}
2942
2943	iph->hop_limit = 32;
2944
2945	iph->payload_len = htons(udplen);
2946	iph->nexthdr = IPPROTO_UDP;
2947
2948	iph->daddr = pkt_dev->cur_in6_daddr;
2949	iph->saddr = pkt_dev->cur_in6_saddr;
2950
2951	skb->protocol = protocol;
2952	skb->dev = odev;
2953	skb->pkt_type = PACKET_HOST;
2954
2955	pktgen_finalize_skb(pkt_dev, skb, datalen);
2956
2957	if (!(pkt_dev->flags & F_UDPCSUM)) {
2958		skb->ip_summed = CHECKSUM_NONE;
2959	} else if (odev->features & (NETIF_F_HW_CSUM | NETIF_F_IPV6_CSUM)) {
2960		skb->ip_summed = CHECKSUM_PARTIAL;
2961		skb->csum_start = skb_transport_header(skb) - skb->head;
2962		skb->csum_offset = offsetof(struct udphdr, check);
2963		udph->check = ~csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, 0);
2964	} else {
2965		__wsum csum = skb_checksum(skb, skb_transport_offset(skb), udplen, 0);
2966
2967		/* add protocol-dependent pseudo-header */
2968		udph->check = csum_ipv6_magic(&iph->saddr, &iph->daddr, udplen, IPPROTO_UDP, csum);
2969
2970		if (udph->check == 0)
2971			udph->check = CSUM_MANGLED_0;
2972	}
2973
2974	return skb;
2975}
2976
2977static struct sk_buff *fill_packet(struct net_device *odev,
2978				   struct pktgen_dev *pkt_dev)
2979{
2980	if (pkt_dev->flags & F_IPV6)
2981		return fill_packet_ipv6(odev, pkt_dev);
2982	else
2983		return fill_packet_ipv4(odev, pkt_dev);
2984}
2985
2986static void pktgen_clear_counters(struct pktgen_dev *pkt_dev)
2987{
2988	pkt_dev->seq_num = 1;
2989	pkt_dev->idle_acc = 0;
2990	pkt_dev->sofar = 0;
2991	pkt_dev->tx_bytes = 0;
2992	pkt_dev->errors = 0;
2993}
2994
2995/* Set up structure for sending pkts, clear counters */
2996
2997static void pktgen_run(struct pktgen_thread *t)
2998{
2999	struct pktgen_dev *pkt_dev;
3000	int started = 0;
3001
3002	func_enter();
3003
3004	rcu_read_lock();
3005	list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3006
3007		/*
3008		 * setup odev and create initial packet.
3009		 */
3010		pktgen_setup_inject(pkt_dev);
3011
3012		if (pkt_dev->odev) {
3013			pktgen_clear_counters(pkt_dev);
3014			pkt_dev->skb = NULL;
3015			pkt_dev->started_at = pkt_dev->next_tx = ktime_get();
3016
3017			set_pkt_overhead(pkt_dev);
3018
3019			strcpy(pkt_dev->result, "Starting");
3020			pkt_dev->running = 1;	/* Cranke yeself! */
3021			started++;
3022		} else
3023			strcpy(pkt_dev->result, "Error starting");
3024	}
3025	rcu_read_unlock();
3026	if (started)
3027		t->control &= ~(T_STOP);
3028}
3029
3030static void pktgen_stop_all_threads_ifs(struct pktgen_net *pn)
3031{
3032	struct pktgen_thread *t;
3033
3034	func_enter();
3035
3036	mutex_lock(&pktgen_thread_lock);
3037
3038	list_for_each_entry(t, &pn->pktgen_threads, th_list)
3039		t->control |= T_STOP;
3040
3041	mutex_unlock(&pktgen_thread_lock);
3042}
3043
3044static int thread_is_running(const struct pktgen_thread *t)
3045{
3046	const struct pktgen_dev *pkt_dev;
3047
3048	rcu_read_lock();
3049	list_for_each_entry_rcu(pkt_dev, &t->if_list, list)
3050		if (pkt_dev->running) {
3051			rcu_read_unlock();
3052			return 1;
3053		}
3054	rcu_read_unlock();
3055	return 0;
3056}
3057
3058static int pktgen_wait_thread_run(struct pktgen_thread *t)
3059{
3060	while (thread_is_running(t)) {
3061
3062		/* note: 't' will still be around even after the unlock/lock
3063		 * cycle because pktgen_thread threads are only cleared at
3064		 * net exit
3065		 */
3066		mutex_unlock(&pktgen_thread_lock);
3067		msleep_interruptible(100);
3068		mutex_lock(&pktgen_thread_lock);
3069
3070		if (signal_pending(current))
3071			goto signal;
3072	}
3073	return 1;
3074signal:
3075	return 0;
3076}
3077
3078static int pktgen_wait_all_threads_run(struct pktgen_net *pn)
3079{
3080	struct pktgen_thread *t;
3081	int sig = 1;
3082
3083	/* prevent from racing with rmmod */
3084	if (!try_module_get(THIS_MODULE))
3085		return sig;
3086
3087	mutex_lock(&pktgen_thread_lock);
3088
3089	list_for_each_entry(t, &pn->pktgen_threads, th_list) {
3090		sig = pktgen_wait_thread_run(t);
3091		if (sig == 0)
3092			break;
3093	}
3094
3095	if (sig == 0)
3096		list_for_each_entry(t, &pn->pktgen_threads, th_list)
3097			t->control |= (T_STOP);
3098
3099	mutex_unlock(&pktgen_thread_lock);
3100	module_put(THIS_MODULE);
3101	return sig;
3102}
3103
3104static void pktgen_run_all_threads(struct pktgen_net *pn)
3105{
3106	struct pktgen_thread *t;
3107
3108	func_enter();
3109
3110	mutex_lock(&pktgen_thread_lock);
3111
3112	list_for_each_entry(t, &pn->pktgen_threads, th_list)
3113		t->control |= (T_RUN);
3114
3115	mutex_unlock(&pktgen_thread_lock);
3116
3117	/* Propagate thread->control  */
3118	schedule_timeout_interruptible(msecs_to_jiffies(125));
3119
3120	pktgen_wait_all_threads_run(pn);
3121}
3122
3123static void pktgen_reset_all_threads(struct pktgen_net *pn)
3124{
3125	struct pktgen_thread *t;
3126
3127	func_enter();
3128
3129	mutex_lock(&pktgen_thread_lock);
3130
3131	list_for_each_entry(t, &pn->pktgen_threads, th_list)
3132		t->control |= (T_REMDEVALL);
3133
3134	mutex_unlock(&pktgen_thread_lock);
3135
3136	/* Propagate thread->control  */
3137	schedule_timeout_interruptible(msecs_to_jiffies(125));
3138
3139	pktgen_wait_all_threads_run(pn);
3140}
3141
3142static void show_results(struct pktgen_dev *pkt_dev, int nr_frags)
3143{
3144	__u64 bps, mbps, pps;
3145	char *p = pkt_dev->result;
3146	ktime_t elapsed = ktime_sub(pkt_dev->stopped_at,
3147				    pkt_dev->started_at);
3148	ktime_t idle = ns_to_ktime(pkt_dev->idle_acc);
3149
3150	p += sprintf(p, "OK: %llu(c%llu+d%llu) usec, %llu (%dbyte,%dfrags)\n",
3151		     (unsigned long long)ktime_to_us(elapsed),
3152		     (unsigned long long)ktime_to_us(ktime_sub(elapsed, idle)),
3153		     (unsigned long long)ktime_to_us(idle),
3154		     (unsigned long long)pkt_dev->sofar,
3155		     pkt_dev->cur_pkt_size, nr_frags);
3156
3157	pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,
3158			ktime_to_ns(elapsed));
3159
3160	bps = pps * 8 * pkt_dev->cur_pkt_size;
3161
3162	mbps = bps;
3163	do_div(mbps, 1000000);
3164	p += sprintf(p, "  %llupps %lluMb/sec (%llubps) errors: %llu",
3165		     (unsigned long long)pps,
3166		     (unsigned long long)mbps,
3167		     (unsigned long long)bps,
3168		     (unsigned long long)pkt_dev->errors);
3169}
3170
3171/* Set stopped-at timer, remove from running list, do counters & statistics */
3172static int pktgen_stop_device(struct pktgen_dev *pkt_dev)
3173{
3174	int nr_frags = pkt_dev->skb ? skb_shinfo(pkt_dev->skb)->nr_frags : -1;
3175
3176	if (!pkt_dev->running) {
3177		pr_warn("interface: %s is already stopped\n",
3178			pkt_dev->odevname);
3179		return -EINVAL;
3180	}
3181
3182	pkt_dev->running = 0;
3183	kfree_skb(pkt_dev->skb);
3184	pkt_dev->skb = NULL;
3185	pkt_dev->stopped_at = ktime_get();
3186
3187	show_results(pkt_dev, nr_frags);
3188
3189	return 0;
3190}
3191
3192static struct pktgen_dev *next_to_run(struct pktgen_thread *t)
3193{
3194	struct pktgen_dev *pkt_dev, *best = NULL;
3195
3196	rcu_read_lock();
3197	list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3198		if (!pkt_dev->running)
3199			continue;
3200		if (best == NULL)
3201			best = pkt_dev;
3202		else if (ktime_compare(pkt_dev->next_tx, best->next_tx) < 0)
3203			best = pkt_dev;
3204	}
3205	rcu_read_unlock();
3206
3207	return best;
3208}
3209
3210static void pktgen_stop(struct pktgen_thread *t)
3211{
3212	struct pktgen_dev *pkt_dev;
3213
3214	func_enter();
3215
3216	rcu_read_lock();
3217
3218	list_for_each_entry_rcu(pkt_dev, &t->if_list, list) {
3219		pktgen_stop_device(pkt_dev);
3220	}
3221
3222	rcu_read_unlock();
3223}
3224
3225/*
3226 * one of our devices needs to be removed - find it
3227 * and remove it
3228 */
3229static void pktgen_rem_one_if(struct pktgen_thread *t)
3230{
3231	struct list_head *q, *n;
3232	struct pktgen_dev *cur;
3233
3234	func_enter();
3235
3236	list_for_each_safe(q, n, &t->if_list) {
3237		cur = list_entry(q, struct pktgen_dev, list);
3238
3239		if (!cur->removal_mark)
3240			continue;
3241
3242		kfree_skb(cur->skb);
3243		cur->skb = NULL;
3244
3245		pktgen_remove_device(t, cur);
3246
3247		break;
3248	}
3249}
3250
3251static void pktgen_rem_all_ifs(struct pktgen_thread *t)
3252{
3253	struct list_head *q, *n;
3254	struct pktgen_dev *cur;
3255
3256	func_enter();
3257
3258	/* Remove all devices, free mem */
3259
3260	list_for_each_safe(q, n, &t->if_list) {
3261		cur = list_entry(q, struct pktgen_dev, list);
3262
3263		kfree_skb(cur->skb);
3264		cur->skb = NULL;
3265
3266		pktgen_remove_device(t, cur);
3267	}
3268}
3269
3270static void pktgen_rem_thread(struct pktgen_thread *t)
3271{
3272	/* Remove from the thread list */
3273	remove_proc_entry(t->tsk->comm, t->net->proc_dir);
3274}
3275
3276static void pktgen_resched(struct pktgen_dev *pkt_dev)
3277{
3278	ktime_t idle_start = ktime_get();
3279	schedule();
3280	pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3281}
3282
3283static void pktgen_wait_for_skb(struct pktgen_dev *pkt_dev)
3284{
3285	ktime_t idle_start = ktime_get();
3286
3287	while (refcount_read(&(pkt_dev->skb->users)) != 1) {
3288		if (signal_pending(current))
3289			break;
3290
3291		if (need_resched())
3292			pktgen_resched(pkt_dev);
3293		else
3294			cpu_relax();
3295	}
3296	pkt_dev->idle_acc += ktime_to_ns(ktime_sub(ktime_get(), idle_start));
3297}
3298
3299static void pktgen_xmit(struct pktgen_dev *pkt_dev)
3300{
3301	unsigned int burst = READ_ONCE(pkt_dev->burst);
3302	struct net_device *odev = pkt_dev->odev;
3303	struct netdev_queue *txq;
3304	struct sk_buff *skb;
3305	int ret;
3306
3307	/* If device is offline, then don't send */
3308	if (unlikely(!netif_running(odev) || !netif_carrier_ok(odev))) {
3309		pktgen_stop_device(pkt_dev);
3310		return;
3311	}
3312
3313	/* This is max DELAY, this has special meaning of
3314	 * "never transmit"
3315	 */
3316	if (unlikely(pkt_dev->delay == ULLONG_MAX)) {
3317		pkt_dev->next_tx = ktime_add_ns(ktime_get(), ULONG_MAX);
3318		return;
3319	}
3320
3321	/* If no skb or clone count exhausted then get new one */
3322	if (!pkt_dev->skb || (pkt_dev->last_ok &&
3323			      ++pkt_dev->clone_count >= pkt_dev->clone_skb)) {
3324		/* build a new pkt */
3325		kfree_skb(pkt_dev->skb);
3326
3327		pkt_dev->skb = fill_packet(odev, pkt_dev);
3328		if (pkt_dev->skb == NULL) {
3329			pr_err("ERROR: couldn't allocate skb in fill_packet\n");
3330			schedule();
3331			pkt_dev->clone_count--;	/* back out increment, OOM */
3332			return;
3333		}
3334		pkt_dev->last_pkt_size = pkt_dev->skb->len;
3335		pkt_dev->clone_count = 0;	/* reset counter */
3336	}
3337
3338	if (pkt_dev->delay && pkt_dev->last_ok)
3339		spin(pkt_dev, pkt_dev->next_tx);
3340
3341	if (pkt_dev->xmit_mode == M_NETIF_RECEIVE) {
3342		skb = pkt_dev->skb;
3343		skb->protocol = eth_type_trans(skb, skb->dev);
3344		refcount_add(burst, &skb->users);
3345		local_bh_disable();
3346		do {
3347			ret = netif_receive_skb(skb);
3348			if (ret == NET_RX_DROP)
3349				pkt_dev->errors++;
3350			pkt_dev->sofar++;
3351			pkt_dev->seq_num++;
3352			if (refcount_read(&skb->users) != burst) {
3353				/* skb was queued by rps/rfs or taps,
3354				 * so cannot reuse this skb
3355				 */
3356				WARN_ON(refcount_sub_and_test(burst - 1, &skb->users));
3357				/* get out of the loop and wait
3358				 * until skb is consumed
3359				 */
3360				break;
3361			}
3362			/* skb was 'freed' by stack, so clean few
3363			 * bits and reuse it
3364			 */
3365			skb_reset_redirect(skb);
3366		} while (--burst > 0);
3367		goto out; /* Skips xmit_mode M_START_XMIT */
3368	} else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) {
3369		local_bh_disable();
3370		refcount_inc(&pkt_dev->skb->users);
3371
3372		ret = dev_queue_xmit(pkt_dev->skb);
3373		switch (ret) {
3374		case NET_XMIT_SUCCESS:
3375			pkt_dev->sofar++;
3376			pkt_dev->seq_num++;
3377			pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3378			break;
3379		case NET_XMIT_DROP:
3380		case NET_XMIT_CN:
3381		/* These are all valid return codes for a qdisc but
3382		 * indicate packets are being dropped or will likely
3383		 * be dropped soon.
3384		 */
3385		case NETDEV_TX_BUSY:
3386		/* qdisc may call dev_hard_start_xmit directly in cases
3387		 * where no queues exist e.g. loopback device, virtual
3388		 * devices, etc. In this case we need to handle
3389		 * NETDEV_TX_ codes.
3390		 */
3391		default:
3392			pkt_dev->errors++;
3393			net_info_ratelimited("%s xmit error: %d\n",
3394					     pkt_dev->odevname, ret);
3395			break;
3396		}
3397		goto out;
3398	}
3399
3400	txq = skb_get_tx_queue(odev, pkt_dev->skb);
3401
3402	local_bh_disable();
3403
3404	HARD_TX_LOCK(odev, txq, smp_processor_id());
3405
3406	if (unlikely(netif_xmit_frozen_or_drv_stopped(txq))) {
3407		pkt_dev->last_ok = 0;
3408		goto unlock;
3409	}
3410	refcount_add(burst, &pkt_dev->skb->users);
3411
3412xmit_more:
3413	ret = netdev_start_xmit(pkt_dev->skb, odev, txq, --burst > 0);
3414
3415	switch (ret) {
3416	case NETDEV_TX_OK:
3417		pkt_dev->last_ok = 1;
3418		pkt_dev->sofar++;
3419		pkt_dev->seq_num++;
3420		pkt_dev->tx_bytes += pkt_dev->last_pkt_size;
3421		if (burst > 0 && !netif_xmit_frozen_or_drv_stopped(txq))
3422			goto xmit_more;
3423		break;
3424	case NET_XMIT_DROP:
3425	case NET_XMIT_CN:
3426		/* skb has been consumed */
3427		pkt_dev->errors++;
3428		break;
3429	default: /* Drivers are not supposed to return other values! */
3430		net_info_ratelimited("%s xmit error: %d\n",
3431				     pkt_dev->odevname, ret);
3432		pkt_dev->errors++;
3433		/* fall through */
3434	case NETDEV_TX_BUSY:
3435		/* Retry it next time */
3436		refcount_dec(&(pkt_dev->skb->users));
3437		pkt_dev->last_ok = 0;
3438	}
3439	if (unlikely(burst))
3440		WARN_ON(refcount_sub_and_test(burst, &pkt_dev->skb->users));
3441unlock:
3442	HARD_TX_UNLOCK(odev, txq);
3443
3444out:
3445	local_bh_enable();
3446
3447	/* If pkt_dev->count is zero, then run forever */
3448	if ((pkt_dev->count != 0) && (pkt_dev->sofar >= pkt_dev->count)) {
3449		pktgen_wait_for_skb(pkt_dev);
3450
3451		/* Done with this */
3452		pktgen_stop_device(pkt_dev);
3453	}
3454}
3455
3456/*
3457 * Main loop of the thread goes here
3458 */
3459
3460static int pktgen_thread_worker(void *arg)
3461{
3462	DEFINE_WAIT(wait);
3463	struct pktgen_thread *t = arg;
3464	struct pktgen_dev *pkt_dev = NULL;
3465	int cpu = t->cpu;
3466
3467	BUG_ON(smp_processor_id() != cpu);
3468
3469	init_waitqueue_head(&t->queue);
3470	complete(&t->start_done);
3471
3472	pr_debug("starting pktgen/%d:  pid=%d\n", cpu, task_pid_nr(current));
3473
3474	set_freezable();
3475
3476	while (!kthread_should_stop()) {
3477		pkt_dev = next_to_run(t);
3478
3479		if (unlikely(!pkt_dev && t->control == 0)) {
3480			if (t->net->pktgen_exiting)
3481				break;
3482			wait_event_interruptible_timeout(t->queue,
3483							 t->control != 0,
3484							 HZ/10);
3485			try_to_freeze();
3486			continue;
3487		}
3488
3489		if (likely(pkt_dev)) {
3490			pktgen_xmit(pkt_dev);
3491
3492			if (need_resched())
3493				pktgen_resched(pkt_dev);
3494			else
3495				cpu_relax();
3496		}
3497
3498		if (t->control & T_STOP) {
3499			pktgen_stop(t);
3500			t->control &= ~(T_STOP);
3501		}
3502
3503		if (t->control & T_RUN) {
3504			pktgen_run(t);
3505			t->control &= ~(T_RUN);
3506		}
3507
3508		if (t->control & T_REMDEVALL) {
3509			pktgen_rem_all_ifs(t);
3510			t->control &= ~(T_REMDEVALL);
3511		}
3512
3513		if (t->control & T_REMDEV) {
3514			pktgen_rem_one_if(t);
3515			t->control &= ~(T_REMDEV);
3516		}
3517
3518		try_to_freeze();
3519	}
3520
3521	pr_debug("%s stopping all device\n", t->tsk->comm);
3522	pktgen_stop(t);
3523
3524	pr_debug("%s removing all device\n", t->tsk->comm);
3525	pktgen_rem_all_ifs(t);
3526
3527	pr_debug("%s removing thread\n", t->tsk->comm);
3528	pktgen_rem_thread(t);
3529
3530	return 0;
3531}
3532
3533static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t,
3534					  const char *ifname, bool exact)
3535{
3536	struct pktgen_dev *p, *pkt_dev = NULL;
3537	size_t len = strlen(ifname);
3538
3539	rcu_read_lock();
3540	list_for_each_entry_rcu(p, &t->if_list, list)
3541		if (strncmp(p->odevname, ifname, len) == 0) {
3542			if (p->odevname[len]) {
3543				if (exact || p->odevname[len] != '@')
3544					continue;
3545			}
3546			pkt_dev = p;
3547			break;
3548		}
3549
3550	rcu_read_unlock();
3551	pr_debug("find_dev(%s) returning %p\n", ifname, pkt_dev);
3552	return pkt_dev;
3553}
3554
3555/*
3556 * Adds a dev at front of if_list.
3557 */
3558
3559static int add_dev_to_thread(struct pktgen_thread *t,
3560			     struct pktgen_dev *pkt_dev)
3561{
3562	int rv = 0;
3563
3564	/* This function cannot be called concurrently, as its called
3565	 * under pktgen_thread_lock mutex, but it can run from
3566	 * userspace on another CPU than the kthread.  The if_lock()
3567	 * is used here to sync with concurrent instances of
3568	 * _rem_dev_from_if_list() invoked via kthread, which is also
3569	 * updating the if_list */
3570	if_lock(t);
3571
3572	if (pkt_dev->pg_thread) {
3573		pr_err("ERROR: already assigned to a thread\n");
3574		rv = -EBUSY;
3575		goto out;
3576	}
3577
3578	pkt_dev->running = 0;
3579	pkt_dev->pg_thread = t;
3580	list_add_rcu(&pkt_dev->list, &t->if_list);
3581
3582out:
3583	if_unlock(t);
3584	return rv;
3585}
3586
3587/* Called under thread lock */
3588
3589static int pktgen_add_device(struct pktgen_thread *t, const char *ifname)
3590{
3591	struct pktgen_dev *pkt_dev;
3592	int err;
3593	int node = cpu_to_node(t->cpu);
3594
3595	/* We don't allow a device to be on several threads */
3596
3597	pkt_dev = __pktgen_NN_threads(t->net, ifname, FIND);
3598	if (pkt_dev) {
3599		pr_err("ERROR: interface already used\n");
3600		return -EBUSY;
3601	}
3602
3603	pkt_dev = kzalloc_node(sizeof(struct pktgen_dev), GFP_KERNEL, node);
3604	if (!pkt_dev)
3605		return -ENOMEM;
3606
3607	strcpy(pkt_dev->odevname, ifname);
3608	pkt_dev->flows = vzalloc_node(array_size(MAX_CFLOWS,
3609						 sizeof(struct flow_state)),
3610				      node);
3611	if (pkt_dev->flows == NULL) {
3612		kfree(pkt_dev);
3613		return -ENOMEM;
3614	}
3615
3616	pkt_dev->removal_mark = 0;
3617	pkt_dev->nfrags = 0;
3618	pkt_dev->delay = pg_delay_d;
3619	pkt_dev->count = pg_count_d;
3620	pkt_dev->sofar = 0;
3621	pkt_dev->udp_src_min = 9;	/* sink port */
3622	pkt_dev->udp_src_max = 9;
3623	pkt_dev->udp_dst_min = 9;
3624	pkt_dev->udp_dst_max = 9;
3625	pkt_dev->vlan_p = 0;
3626	pkt_dev->vlan_cfi = 0;
3627	pkt_dev->vlan_id = 0xffff;
3628	pkt_dev->svlan_p = 0;
3629	pkt_dev->svlan_cfi = 0;
3630	pkt_dev->svlan_id = 0xffff;
3631	pkt_dev->burst = 1;
3632	pkt_dev->node = NUMA_NO_NODE;
3633
3634	err = pktgen_setup_dev(t->net, pkt_dev, ifname);
3635	if (err)
3636		goto out1;
3637	if (pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)
3638		pkt_dev->clone_skb = pg_clone_skb_d;
3639
3640	pkt_dev->entry = proc_create_data(ifname, 0600, t->net->proc_dir,
3641					  &pktgen_if_proc_ops, pkt_dev);
3642	if (!pkt_dev->entry) {
3643		pr_err("cannot create %s/%s procfs entry\n",
3644		       PG_PROC_DIR, ifname);
3645		err = -EINVAL;
3646		goto out2;
3647	}
3648#ifdef CONFIG_XFRM
3649	pkt_dev->ipsmode = XFRM_MODE_TRANSPORT;
3650	pkt_dev->ipsproto = IPPROTO_ESP;
3651
3652	/* xfrm tunnel mode needs additional dst to extract outter
3653	 * ip header protocol/ttl/id field, here creat a phony one.
3654	 * instead of looking for a valid rt, which definitely hurting
3655	 * performance under such circumstance.
3656	 */
3657	pkt_dev->dstops.family = AF_INET;
3658	pkt_dev->xdst.u.dst.dev = pkt_dev->odev;
3659	dst_init_metrics(&pkt_dev->xdst.u.dst, pktgen_dst_metrics, false);
3660	pkt_dev->xdst.child = &pkt_dev->xdst.u.dst;
3661	pkt_dev->xdst.u.dst.ops = &pkt_dev->dstops;
3662#endif
3663
3664	return add_dev_to_thread(t, pkt_dev);
3665out2:
3666	dev_put(pkt_dev->odev);
3667out1:
3668#ifdef CONFIG_XFRM
3669	free_SAs(pkt_dev);
3670#endif
3671	vfree(pkt_dev->flows);
3672	kfree(pkt_dev);
3673	return err;
3674}
3675
3676static int __net_init pktgen_create_thread(int cpu, struct pktgen_net *pn)
3677{
3678	struct pktgen_thread *t;
3679	struct proc_dir_entry *pe;
3680	struct task_struct *p;
3681
3682	t = kzalloc_node(sizeof(struct pktgen_thread), GFP_KERNEL,
3683			 cpu_to_node(cpu));
3684	if (!t) {
3685		pr_err("ERROR: out of memory, can't create new thread\n");
3686		return -ENOMEM;
3687	}
3688
3689	mutex_init(&t->if_lock);
3690	t->cpu = cpu;
3691
3692	INIT_LIST_HEAD(&t->if_list);
3693
3694	list_add_tail(&t->th_list, &pn->pktgen_threads);
3695	init_completion(&t->start_done);
3696
3697	p = kthread_create_on_node(pktgen_thread_worker,
3698				   t,
3699				   cpu_to_node(cpu),
3700				   "kpktgend_%d", cpu);
3701	if (IS_ERR(p)) {
3702		pr_err("kernel_thread() failed for cpu %d\n", t->cpu);
3703		list_del(&t->th_list);
3704		kfree(t);
3705		return PTR_ERR(p);
3706	}
3707	kthread_bind(p, cpu);
3708	t->tsk = p;
3709
3710	pe = proc_create_data(t->tsk->comm, 0600, pn->proc_dir,
3711			      &pktgen_thread_proc_ops, t);
3712	if (!pe) {
3713		pr_err("cannot create %s/%s procfs entry\n",
3714		       PG_PROC_DIR, t->tsk->comm);
3715		kthread_stop(p);
3716		list_del(&t->th_list);
3717		kfree(t);
3718		return -EINVAL;
3719	}
3720
3721	t->net = pn;
3722	get_task_struct(p);
3723	wake_up_process(p);
3724	wait_for_completion(&t->start_done);
3725
3726	return 0;
3727}
3728
3729/*
3730 * Removes a device from the thread if_list.
3731 */
3732static void _rem_dev_from_if_list(struct pktgen_thread *t,
3733				  struct pktgen_dev *pkt_dev)
3734{
3735	struct list_head *q, *n;
3736	struct pktgen_dev *p;
3737
3738	if_lock(t);
3739	list_for_each_safe(q, n, &t->if_list) {
3740		p = list_entry(q, struct pktgen_dev, list);
3741		if (p == pkt_dev)
3742			list_del_rcu(&p->list);
3743	}
3744	if_unlock(t);
3745}
3746
3747static int pktgen_remove_device(struct pktgen_thread *t,
3748				struct pktgen_dev *pkt_dev)
3749{
3750	pr_debug("remove_device pkt_dev=%p\n", pkt_dev);
3751
3752	if (pkt_dev->running) {
3753		pr_warn("WARNING: trying to remove a running interface, stopping it now\n");
3754		pktgen_stop_device(pkt_dev);
3755	}
3756
3757	/* Dis-associate from the interface */
3758
3759	if (pkt_dev->odev) {
3760		dev_put(pkt_dev->odev);
3761		pkt_dev->odev = NULL;
3762	}
3763
3764	/* Remove proc before if_list entry, because add_device uses
3765	 * list to determine if interface already exist, avoid race
3766	 * with proc_create_data() */
3767	proc_remove(pkt_dev->entry);
3768
3769	/* And update the thread if_list */
3770	_rem_dev_from_if_list(t, pkt_dev);
3771
3772#ifdef CONFIG_XFRM
3773	free_SAs(pkt_dev);
3774#endif
3775	vfree(pkt_dev->flows);
3776	if (pkt_dev->page)
3777		put_page(pkt_dev->page);
3778	kfree_rcu(pkt_dev, rcu);
3779	return 0;
3780}
3781
3782static int __net_init pg_net_init(struct net *net)
3783{
3784	struct pktgen_net *pn = net_generic(net, pg_net_id);
3785	struct proc_dir_entry *pe;
3786	int cpu, ret = 0;
3787
3788	pn->net = net;
3789	INIT_LIST_HEAD(&pn->pktgen_threads);
3790	pn->pktgen_exiting = false;
3791	pn->proc_dir = proc_mkdir(PG_PROC_DIR, pn->net->proc_net);
3792	if (!pn->proc_dir) {
3793		pr_warn("cannot create /proc/net/%s\n", PG_PROC_DIR);
3794		return -ENODEV;
3795	}
3796	pe = proc_create(PGCTRL, 0600, pn->proc_dir, &pktgen_proc_ops);
3797	if (pe == NULL) {
3798		pr_err("cannot create %s procfs entry\n", PGCTRL);
3799		ret = -EINVAL;
3800		goto remove;
3801	}
3802
3803	for_each_online_cpu(cpu) {
3804		int err;
3805
3806		err = pktgen_create_thread(cpu, pn);
3807		if (err)
3808			pr_warn("Cannot create thread for cpu %d (%d)\n",
3809				   cpu, err);
3810	}
3811
3812	if (list_empty(&pn->pktgen_threads)) {
3813		pr_err("Initialization failed for all threads\n");
3814		ret = -ENODEV;
3815		goto remove_entry;
3816	}
3817
3818	return 0;
3819
3820remove_entry:
3821	remove_proc_entry(PGCTRL, pn->proc_dir);
3822remove:
3823	remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
3824	return ret;
3825}
3826
3827static void __net_exit pg_net_exit(struct net *net)
3828{
3829	struct pktgen_net *pn = net_generic(net, pg_net_id);
3830	struct pktgen_thread *t;
3831	struct list_head *q, *n;
3832	LIST_HEAD(list);
3833
3834	/* Stop all interfaces & threads */
3835	pn->pktgen_exiting = true;
3836
3837	mutex_lock(&pktgen_thread_lock);
3838	list_splice_init(&pn->pktgen_threads, &list);
3839	mutex_unlock(&pktgen_thread_lock);
3840
3841	list_for_each_safe(q, n, &list) {
3842		t = list_entry(q, struct pktgen_thread, th_list);
3843		list_del(&t->th_list);
3844		kthread_stop(t->tsk);
3845		put_task_struct(t->tsk);
3846		kfree(t);
3847	}
3848
3849	remove_proc_entry(PGCTRL, pn->proc_dir);
3850	remove_proc_entry(PG_PROC_DIR, pn->net->proc_net);
3851}
3852
3853static struct pernet_operations pg_net_ops = {
3854	.init = pg_net_init,
3855	.exit = pg_net_exit,
3856	.id   = &pg_net_id,
3857	.size = sizeof(struct pktgen_net),
3858};
3859
3860static int __init pg_init(void)
3861{
3862	int ret = 0;
3863
3864	pr_info("%s", version);
3865	ret = register_pernet_subsys(&pg_net_ops);
3866	if (ret)
3867		return ret;
3868	ret = register_netdevice_notifier(&pktgen_notifier_block);
3869	if (ret)
3870		unregister_pernet_subsys(&pg_net_ops);
3871
3872	return ret;
3873}
3874
3875static void __exit pg_cleanup(void)
3876{
3877	unregister_netdevice_notifier(&pktgen_notifier_block);
3878	unregister_pernet_subsys(&pg_net_ops);
3879	/* Don't need rcu_barrier() due to use of kfree_rcu() */
3880}
3881
3882module_init(pg_init);
3883module_exit(pg_cleanup);
3884
3885MODULE_AUTHOR("Robert Olsson <robert.olsson@its.uu.se>");
3886MODULE_DESCRIPTION("Packet Generator tool");
3887MODULE_LICENSE("GPL");
3888MODULE_VERSION(VERSION);
3889module_param(pg_count_d, int, 0);
3890MODULE_PARM_DESC(pg_count_d, "Default number of packets to inject");
3891module_param(pg_delay_d, int, 0);
3892MODULE_PARM_DESC(pg_delay_d, "Default delay between packets (nanoseconds)");
3893module_param(pg_clone_skb_d, int, 0);
3894MODULE_PARM_DESC(pg_clone_skb_d, "Default number of copies of the same packet");
3895module_param(debug, int, 0);
3896MODULE_PARM_DESC(debug, "Enable debugging of pktgen module");