PageRenderTime 121ms CodeModel.GetById 16ms app.highlight 90ms 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

Large files files are truncated, but you can click here to view the full 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++

Large files files are truncated, but you can click here to view the full file