net/core/pktgen.c

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