cregit-Linux how code gets into the kernel

Release 4.8 net/core/pktgen.c

Directory: net/core
/*
 * Authors:
 * Copyright 2001, 2002 by Robert Olsson <robert.olsson@its.uu.se>
 *                             Uppsala University and
 *                             Swedish University of Agricultural Sciences
 *
 * Alexey Kuznetsov  <kuznet@ms2.inr.ac.ru>
 * Ben Greear <greearb@candelatech.com>
 * Jens Låås <jens.laas@data.slu.se>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 *
 * A tool for loading the network with preconfigurated packets.
 * The tool is implemented as a linux module.  Parameters are output
 * device, delay (to hard_xmit), number of packets, and whether
 * to use multiple SKBs or just the same one.
 * pktgen uses the installed interface's output routine.
 *
 * Additional hacking by:
 *
 * Jens.Laas@data.slu.se
 * Improved by ANK. 010120.
 * Improved by ANK even more. 010212.
 * MAC address typo fixed. 010417 --ro
 * Integrated.  020301 --DaveM
 * Added multiskb option 020301 --DaveM
 * Scaling of results. 020417--sigurdur@linpro.no
 * Significant re-work of the module:
 *   *  Convert to threaded model to more efficiently be able to transmit
 *       and receive on multiple interfaces at once.
 *   *  Converted many counters to __u64 to allow longer runs.
 *   *  Allow configuration of ranges, like min/max IP address, MACs,
 *       and UDP-ports, for both source and destination, and can
 *       set to use a random distribution or sequentially walk the range.
 *   *  Can now change most values after starting.
 *   *  Place 12-byte packet in UDP payload with magic number,
 *       sequence number, and timestamp.
 *   *  Add receiver code that detects dropped pkts, re-ordered pkts, and
 *       latencies (with micro-second) precision.
 *   *  Add IOCTL interface to easily get counters & configuration.
 *   --Ben Greear <greearb@candelatech.com>
 *
 * Renamed multiskb to clone_skb and cleaned up sending core for two distinct
 * skb modes. A clone_skb=0 mode for Ben "ranges" work and a clone_skb != 0
 * as a "fastpath" with a configurable number of clones after alloc's.
 * clone_skb=0 means all packets are allocated this also means ranges time
 * stamps etc can be used. clone_skb=100 means 1 malloc is followed by 100
 * clones.
 *
 * Also moved to /proc/net/pktgen/
 * --ro
 *
 * Sept 10:  Fixed threading/locking.  Lots of bone-headed and more clever
 *    mistakes.  Also merged in DaveM's patch in the -pre6 patch.
 * --Ben Greear <greearb@candelatech.com>
 *
 * Integrated to 2.5.x 021029 --Lucio Maciel (luciomaciel@zipmail.com.br)
 *
 *
 * 021124 Finished major redesign and rewrite for new functionality.
 * See Documentation/networking/pktgen.txt for how to use this.
 *
 * The new operation:
 * For each CPU one thread/process is created at start. This process checks
 * for running devices in the if_list and sends packets until count is 0 it
 * also the thread checks the thread->control which is used for inter-process
 * communication. controlling process "posts" operations to the threads this
 * way.
 * The if_list is RCU protected, and the if_lock remains to protect updating
 * of if_list, from "add_device" as it invoked from userspace (via proc write).
 *
 * By design there should only be *one* "controlling" process. In practice
 * multiple write accesses gives unpredictable result. Understood by "write"
 * to /proc gives result code thats should be read be the "writer".
 * For practical use this should be no problem.
 *
 * Note when adding devices to a specific CPU there good idea to also assign
 * /proc/irq/XX/smp_affinity so TX-interrupts gets bound to the same CPU.
 * --ro
 *
 * Fix refcount off by one if first packet fails, potential null deref,
 * memleak 030710- KJP
 *
 * First "ranges" functionality for ipv6 030726 --ro
 *
 * Included flow support. 030802 ANK.
 *
 * Fixed unaligned access on IA-64 Grant Grundler <grundler@parisc-linux.org>
 *
 * Remove if fix from added Harald Welte <laforge@netfilter.org> 040419
 * ia64 compilation fix from  Aron Griffis <aron@hp.com> 040604
 *
 * New xmit() return, do_div and misc clean up by Stephen Hemminger
 * <shemminger@osdl.org> 040923
 *
 * Randy Dunlap fixed u64 printk compiler warning
 *
 * Remove FCS from BW calculation.  Lennert Buytenhek <buytenh@wantstofly.org>
 * New time handling. Lennert Buytenhek <buytenh@wantstofly.org> 041213
 *
 * Corrections from Nikolai Malykh (nmalykh@bilim.com)
 * Removed unused flags F_SET_SRCMAC & F_SET_SRCIP 041230
 *
 * interruptible_sleep_on_timeout() replaced Nishanth Aravamudan <nacc@us.ibm.com>
 * 050103
 *
 * MPLS support by Steven Whitehouse <steve@chygwyn.com>
 *
 * 802.1Q/Q-in-Q support by Francesco Fondelli (FF) <francesco.fondelli@gmail.com>
 *
 * Fixed src_mac command to set source mac of packet to value specified in
 * command by Adit Ranadive <adit.262@gmail.com>
 *
 */


#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/sys.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/unistd.h>
#include <linux/string.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/capability.h>
#include <linux/hrtimer.h>
#include <linux/freezer.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/list.h>
#include <linux/init.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/inet.h>
#include <linux/inetdevice.h>
#include <linux/rtnetlink.h>
#include <linux/if_arp.h>
#include <linux/if_vlan.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/ipv6.h>
#include <linux/udp.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/wait.h>
#include <linux/etherdevice.h>
#include <linux/kthread.h>
#include <linux/prefetch.h>
#include <net/net_namespace.h>
#include <net/checksum.h>
#include <net/ipv6.h>
#include <net/udp.h>
#include <net/ip6_checksum.h>
#include <net/addrconf.h>
#ifdef CONFIG_XFRM
#include <net/xfrm.h>
#endif
#include <net/netns/generic.h>
#include <asm/byteorder.h>
#include <linux/rcupdate.h>
#include <linux/bitops.h>
#include <linux/io.h>
#include <linux/timex.h>
#include <linux/uaccess.h>
#include <asm/dma.h>
#include <asm/div64.h>		/* do_div */


#define VERSION	"2.75"

#define IP_NAME_SZ 32

#define MAX_MPLS_LABELS 16 
/* This is the max label stack depth */

#define MPLS_STACK_BOTTOM htonl(0x00000100)


#define func_enter() pr_debug("entering %s\n", __func__);

/* Device flag bits */

#define F_IPSRC_RND   (1<<0)	
/* IP-Src Random  */

#define F_IPDST_RND   (1<<1)	
/* IP-Dst Random  */

#define F_UDPSRC_RND  (1<<2)	
/* UDP-Src Random */

#define F_UDPDST_RND  (1<<3)	
/* UDP-Dst Random */

#define F_MACSRC_RND  (1<<4)	
/* MAC-Src Random */

#define F_MACDST_RND  (1<<5)	
/* MAC-Dst Random */

#define F_TXSIZE_RND  (1<<6)	
/* Transmit size is random */

#define F_IPV6        (1<<7)	
/* Interface in IPV6 Mode */

#define F_MPLS_RND    (1<<8)	
/* Random MPLS labels */

#define F_VID_RND     (1<<9)	
/* Random VLAN ID */

#define F_SVID_RND    (1<<10)	
/* Random SVLAN ID */

#define F_FLOW_SEQ    (1<<11)	
/* Sequential flows */

#define F_IPSEC_ON    (1<<12)	
/* ipsec on for flows */

#define F_QUEUE_MAP_RND (1<<13)	
/* queue map Random */

#define F_QUEUE_MAP_CPU (1<<14)	
/* queue map mirrors smp_processor_id() */

#define F_NODE          (1<<15)	
/* Node memory alloc*/

#define F_UDPCSUM       (1<<16)	
/* Include UDP checksum */

#define F_NO_TIMESTAMP  (1<<17)	
/* Don't timestamp packets (default TS) */

/* Thread control flag bits */

#define T_STOP        (1<<0)	
/* Stop run */

#define T_RUN         (1<<1)	
/* Start run */

#define T_REMDEVALL   (1<<2)	
/* Remove all devs */

#define T_REMDEV      (1<<3)	
/* Remove one dev */

/* Xmit modes */

#define M_START_XMIT		0	
/* Default normal TX */

#define M_NETIF_RECEIVE 	1	
/* Inject packets into stack */

#define M_QUEUE_XMIT		2	
/* Inject packet into qdisc */

/* If lock -- protects updating of if_list */

#define   if_lock(t)           spin_lock(&(t->if_lock));

#define   if_unlock(t)           spin_unlock(&(t->if_lock));

/* Used to help with determining the pkts on receive */

#define PKTGEN_MAGIC 0xbe9be955

#define PG_PROC_DIR "pktgen"

#define PGCTRL	    "pgctrl"


#define MAX_CFLOWS  65536


#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)

#define SVLAN_TAG_SIZE(x) ((x)->svlan_id == 0xffff ? 0 : 4)


struct flow_state {
	
__be32 cur_daddr;
	
int count;
#ifdef CONFIG_XFRM
	
struct xfrm_state *x;
#endif
	
__u32 flags;
};

/* flow flag bits */

#define F_INIT   (1<<0)		
/* flow has been initialized */


struct pktgen_dev {
	/*
         * Try to keep frequent/infrequent used vars. separated.
         */
	
struct proc_dir_entry *entry;	/* proc file */
	
struct pktgen_thread *pg_thread;/* the owner */
	
struct list_head list;		/* chaining in the thread's run-queue */
	
struct rcu_head	 rcu;		/* freed by RCU */

	
int running;		/* if false, the test will stop */

	/* If min != max, then we will either do a linear iteration, or
         * we will do a random selection from within the range.
         */
	
__u32 flags;
	
int xmit_mode;
	
int min_pkt_size;
	
int max_pkt_size;
	
int pkt_overhead;	/* overhead for MPLS, VLANs, IPSEC etc */
	
int nfrags;
	
int removal_mark;	/* non-zero => the device is marked for
                                 * removal by worker thread */

	
struct page *page;
	
u64 delay;		/* nano-seconds */

	
__u64 count;		/* Default No packets to send */
	
__u64 sofar;		/* How many pkts we've sent so far */
	
__u64 tx_bytes;		/* How many bytes we've transmitted */
	
__u64 errors;		/* Errors when trying to transmit, */

	/* runtime counters relating to clone_skb */

	
__u32 clone_count;
	
int last_ok;		/* Was last skb sent?
                                 * Or a failed transmit of some sort?
                                 * This will keep sequence numbers in order
                                 */
	
ktime_t next_tx;
	
ktime_t started_at;
	
ktime_t stopped_at;
	
u64	idle_acc;	/* nano-seconds */

	
__u32 seq_num;

	
int clone_skb;		/*
                                 * Use multiple SKBs during packet gen.
                                 * If this number is greater than 1, then
                                 * that many copies of the same packet will be
                                 * sent before a new packet is allocated.
                                 * If you want to send 1024 identical packets
                                 * before creating a new packet,
                                 * set clone_skb to 1024.
                                 */

	
char dst_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
	
char dst_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
	
char src_min[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */
	
char src_max[IP_NAME_SZ];	/* IP, ie 1.2.3.4 */

	
struct in6_addr in6_saddr;
	
struct in6_addr in6_daddr;
	
struct in6_addr cur_in6_daddr;
	
struct in6_addr cur_in6_saddr;
	/* For ranges */
	
struct in6_addr min_in6_daddr;
	
struct in6_addr max_in6_daddr;
	
struct in6_addr min_in6_saddr;
	
struct in6_addr max_in6_saddr;

	/* If we're doing ranges, random or incremental, then this
         * defines the min/max for those ranges.
         */
	
__be32 saddr_min;	/* inclusive, source IP address */
	
__be32 saddr_max;	/* exclusive, source IP address */
	
__be32 daddr_min;	/* inclusive, dest IP address */
	
__be32 daddr_max;	/* exclusive, dest IP address */

	
__u16 udp_src_min;	/* inclusive, source UDP port */
	
__u16 udp_src_max;	/* exclusive, source UDP port */
	
__u16 udp_dst_min;	/* inclusive, dest UDP port */
	
__u16 udp_dst_max;	/* exclusive, dest UDP port */

	/* DSCP + ECN */
	
__u8 tos;            /* six MSB of (former) IPv4 TOS
                                are for dscp codepoint */
	
__u8 traffic_class;  /* ditto for the (former) Traffic Class in IPv6
                                (see RFC 3260, sec. 4) */

	/* MPLS */
	
unsigned int nr_labels;	/* Depth of stack, 0 = no MPLS */
	
__be32 labels[MAX_MPLS_LABELS];

	/* VLAN/SVLAN (802.1Q/Q-in-Q) */
	
__u8  vlan_p;
	
__u8  vlan_cfi;
	
__u16 vlan_id;  /* 0xffff means no vlan tag */

	
__u8  svlan_p;
	
__u8  svlan_cfi;
	
__u16 svlan_id; /* 0xffff means no svlan tag */

	
__u32 src_mac_count;	/* How many MACs to iterate through */
	
__u32 dst_mac_count;	/* How many MACs to iterate through */

	
unsigned char dst_mac[ETH_ALEN];
	
unsigned char src_mac[ETH_ALEN];

	
__u32 cur_dst_mac_offset;
	
__u32 cur_src_mac_offset;
	
__be32 cur_saddr;
	
__be32 cur_daddr;
	
__u16 ip_id;
	
__u16 cur_udp_dst;
	
__u16 cur_udp_src;
	
__u16 cur_queue_map;
	
__u32 cur_pkt_size;
	
__u32 last_pkt_size;

	
__u8 hh[14];
	/* = {
           0x00, 0x80, 0xC8, 0x79, 0xB3, 0xCB,

           We fill in SRC address later
           0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
           0x08, 0x00
           };
         */
	
__u16 pad;		/* pad out the hh struct to an even 16 bytes */

	
struct sk_buff *skb;	/* skb we are to transmit next, used for when we
                                 * are transmitting the same one multiple times
                                 */
	
struct net_device *odev; /* The out-going device.
                                  * Note that the device should have it's
                                  * pg_info pointer pointing back to this
                                  * device.
                                  * Set when the user specifies the out-going
                                  * device name (not when the inject is
                                  * started as it used to do.)
                                  */
	
char odevname[32];
	
struct flow_state *flows;
	
unsigned int cflows;	/* Concurrent flows (config) */
	
unsigned int lflow;		/* Flow length  (config) */
	
unsigned int nflows;	/* accumulated flows (stats) */
	
unsigned int curfl;		/* current sequenced flow (state)*/

	
u16 queue_map_min;
	
u16 queue_map_max;
	
__u32 skb_priority;	/* skb priority field */
	
unsigned int burst;	/* number of duplicated packets to burst */
	
int node;               /* Memory node */

#ifdef CONFIG_XFRM
	
__u8	ipsmode;		/* IPSEC mode (config) */
	
__u8	ipsproto;		/* IPSEC type (config) */
	
__u32	spi;
	
struct dst_entry dst;
	
struct dst_ops dstops;
#endif
	
char result[512];
};


struct pktgen_hdr {
	
__be32 pgh_magic;
	
__be32 seq_num;
	
__be32 tv_sec;
	
__be32 tv_usec;
};



static int pg_net_id __read_mostly;


struct pktgen_net {
	
struct net		*net;
	
struct proc_dir_entry	*proc_dir;
	
struct list_head	pktgen_threads;
	
bool			pktgen_exiting;
};


struct pktgen_thread {
	
spinlock_t if_lock;		/* for list of devices */
	
struct list_head if_list;	/* All device here */
	
struct list_head th_list;
	
struct task_struct *tsk;
	
char result[512];

	/* Field for thread to receive "posted" events terminate,
           stop ifs etc. */

	
u32 control;
	
int cpu;

	
wait_queue_head_t queue;
	
struct completion start_done;
	
struct pktgen_net *net;
};


#define REMOVE 1

#define FIND   0


static const char version[] =
	"Packet Generator for packet performance testing. "
	"Version: " VERSION "\n";

static int pktgen_remove_device(struct pktgen_thread *t, struct pktgen_dev *i);
static int pktgen_add_device(struct pktgen_thread *t, const char *ifname);
static struct pktgen_dev *pktgen_find_dev(struct pktgen_thread *t,
					  const char *ifname, bool exact);
static int pktgen_device_event(struct notifier_block *, unsigned long, void *);
static void pktgen_run_all_threads(struct pktgen_net *pn);
static void pktgen_reset_all_threads(struct pktgen_net *pn);
static void pktgen_stop_all_threads_ifs(struct pktgen_net *pn);

static void pktgen_stop(struct pktgen_thread *t);
static void pktgen_clear_counters(struct pktgen_dev *pkt_dev);

/* Module parameters, defaults. */

static int pg_count_d __read_mostly = 1000;

static int pg_delay_d __read_mostly;

static int pg_clone_skb_d  __read_mostly;

static int debug  __read_mostly;

static DEFINE_MUTEX(pktgen_thread_lock);


static struct notifier_block pktgen_notifier_block = {
	.notifier_call = pktgen_device_event,
};

/*
 * /proc handling functions
 *
 */


static int pgctrl_show(struct seq_file *seq, void *v) { seq_puts(seq, version); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
robert olssonrobert olsson1456.00%133.33%
stephen hemmingerstephen hemminger1144.00%266.67%
Total25100.00%3100.00%


static ssize_t pgctrl_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos) { char data[128]; struct pktgen_net *pn = net_generic(current->nsproxy->net_ns, pg_net_id); if (!capable(CAP_NET_ADMIN)) return -EPERM; if (count == 0) return -EINVAL; if (count > sizeof(data)) count = sizeof(data); if (copy_from_user(data, buf, count)) return -EFAULT; data[count - 1] = 0; /* Strip trailing '\n' and terminate string */ if (!strcmp(data, "stop")) pktgen_stop_all_threads_ifs(pn); else if (!strcmp(data, "start")) pktgen_run_all_threads(pn); else if (!strcmp(data, "reset")) pktgen_reset_all_threads(pn); else return -EINVAL; return count; }

Contributors

PersonTokensPropCommitsCommitProp
robert olssonrobert olsson8853.66%112.50%
americo wangamerico wang2515.24%112.50%
stephen hemmingerstephen hemminger1710.37%112.50%
mathias krausemathias krause169.76%225.00%
jesse brandeburgjesse brandeburg137.93%112.50%
jesper dangaard brouerjesper dangaard brouer42.44%112.50%
al viroal viro10.61%112.50%
Total164100.00%8100.00%


static int pgctrl_open(struct inode *inode, struct file *file) { return single_open(file, pgctrl_show, PDE_DATA(inode)); }

Contributors

PersonTokensPropCommitsCommitProp
stephen hemmingerstephen hemminger2275.86%133.33%
robert olssonrobert olsson620.69%133.33%
al viroal viro13.45%133.33%
Total29100.00%3100.00%

static const struct file_operations pktgen_fops = { .owner = THIS_MODULE, .open = pgctrl_open, .read = seq_read, .llseek = seq_lseek, .write = pgctrl_write, .release = single_release, };
static int pktgen_if_show(struct seq_file *seq, void *v) { const struct pktgen_dev *pkt_dev = seq->private; ktime_t stopped; u64 idle; seq_printf(seq, "Params: count %llu min_pkt_size: %u max_pkt_size: %u\n", (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size, pkt_dev->max_pkt_size); seq_printf(seq, " frags: %d delay: %llu clone_skb: %d ifname: %s\n", pkt_dev->nfrags, (unsigned long long) pkt_dev->delay, pkt_dev->clone_skb, pkt_dev->odevname); seq_printf(seq, " flows: %u flowlen: %u\n", pkt_dev->cflows, pkt_dev->lflow); seq_printf(seq, " queue_map_min: %u queue_map_max: %u\n", pkt_dev->queue_map_min, pkt_dev->queue_map_max); if (pkt_dev->skb_priority) seq_printf(seq, " skb_priority: %u\n", pkt_dev->skb_priority); if (pkt_dev->flags & F_IPV6) { seq_printf(seq, " saddr: %pI6c min_saddr: %pI6c max_saddr: %pI6c\n" " daddr: %pI6c min_daddr: %pI6c max_daddr: %pI6c\n", &pkt_dev->in6_saddr, &pkt_dev->min_in6_saddr, &pkt_dev->max_in6_saddr, &pkt_dev->in6_daddr, &pkt_dev->min_in6_daddr, &pkt_dev->max_in6_daddr); } else { seq_printf(seq, " dst_min: %s dst_max: %s\n", pkt_dev->dst_min, pkt_dev->dst_max); seq_printf(seq, " src_min: %s src_max: %s\n", pkt_dev->src_min, pkt_dev->src_max); } seq_puts(seq, " src_mac: "); seq_printf(seq, "%pM ", is_zero_ether_addr(pkt_dev->src_mac) ? pkt_dev->odev->dev_addr : pkt_dev->src_mac); seq_puts(seq, "dst_mac: "); seq_printf(seq, "%pM\n", pkt_dev->dst_mac); seq_printf(seq, " udp_src_min: %d udp_src_max: %d" " udp_dst_min: %d udp_dst_max: %d\n", pkt_dev->udp_src_min, pkt_dev->udp_src_max, pkt_dev->udp_dst_min, pkt_dev->udp_dst_max); seq_printf(seq, " src_mac_count: %d dst_mac_count: %d\n", pkt_dev->src_mac_count, pkt_dev->dst_mac_count); if (pkt_dev->nr_labels) { unsigned int i; seq_puts(seq, " mpls: "); for (i = 0; i < pkt_dev->nr_labels; i++) seq_printf(seq, "%08x%s", ntohl(pkt_dev->labels[i]), i == pkt_dev->nr_labels-1 ? "\n" : ", "); } if (pkt_dev->vlan_id != 0xffff) seq_printf(seq, " vlan_id: %u vlan_p: %u vlan_cfi: %u\n", pkt_dev->vlan_id, pkt_dev->vlan_p, pkt_dev->vlan_cfi); if (pkt_dev->svlan_id != 0xffff) seq_printf(seq, " svlan_id: %u vlan_p: %u vlan_cfi: %u\n", pkt_dev->svlan_id, pkt_dev->svlan_p, pkt_dev->svlan_cfi); if (pkt_dev->tos) seq_printf(seq, " tos: 0x%02x\n", pkt_dev->tos); if (pkt_dev->traffic_class) seq_printf(seq, " traffic_class: 0x%02x\n", pkt_dev->traffic_class); if (pkt_dev->burst > 1) seq_printf(seq, " burst: %d\n", pkt_dev->burst); if (pkt_dev->node >= 0) seq_printf(seq, " node: %d\n", pkt_dev->node); if (pkt_dev->xmit_mode == M_NETIF_RECEIVE) seq_puts(seq, " xmit_mode: netif_receive\n"); else if (pkt_dev->xmit_mode == M_QUEUE_XMIT) seq_puts(seq, " xmit_mode: xmit_queue\n"); seq_puts(seq, " Flags: "); if (pkt_dev->flags & F_IPV6) seq_puts(seq, "IPV6 "); if (pkt_dev->flags & F_IPSRC_RND) seq_puts(seq, "IPSRC_RND "); if (pkt_dev->flags & F_IPDST_RND) seq_puts(seq, "IPDST_RND "); if (pkt_dev->flags & F_TXSIZE_RND) seq_puts(seq, "TXSIZE_RND "); if (pkt_dev->flags & F_UDPSRC_RND) seq_puts(seq, "UDPSRC_RND "); if (pkt_dev->flags & F_UDPDST_RND) seq_puts(seq, "UDPDST_RND "); if (pkt_dev->flags & F_UDPCSUM) seq_puts(seq, "UDPCSUM "); if (pkt_dev->flags & F_NO_TIMESTAMP) seq_puts(seq, "NO_TIMESTAMP "); if (pkt_dev->flags & F_MPLS_RND) seq_puts(seq, "MPLS_RND "); if (pkt_dev->flags & F_QUEUE_MAP_RND) seq_puts(seq, "QUEUE_MAP_RND "); if (pkt_dev->flags & F_QUEUE_MAP_CPU) seq_puts(seq, "QUEUE_MAP_CPU "); if (pkt_dev->cflows) { if (pkt_dev->flags & F_FLOW_SEQ) seq_puts(seq, "FLOW_SEQ "); /*in sequence flows*/ else seq_puts(seq, "FLOW_RND "); } #ifdef CONFIG_XFRM if (pkt_dev->flags & F_IPSEC_ON) { seq_puts(seq, "IPSEC "); if (pkt_dev->spi) seq_printf(seq, "spi:%u", pkt_dev->spi); } #endif if (pkt_dev->flags & F_MACSRC_RND) seq_puts(seq, "MACSRC_RND "); if (pkt_dev->flags & F_MACDST_RND) seq_puts(seq, "MACDST_RND "); if (pkt_dev->flags & F_VID_RND) seq_puts(seq, "VID_RND "); if (pkt_dev->flags & F_SVID_RND) seq_puts(seq, "SVID_RND "); if (pkt_dev->flags & F_NODE) seq_puts(seq, "NODE_ALLOC "); seq_puts(seq, "\n"); /* not really stopped, more like last-running-at */ stopped = pkt_dev->running ? ktime_get() : pkt_dev->stopped_at; idle = pkt_dev->idle_acc; do_div(idle, NSEC_PER_USEC); seq_printf(seq, "Current:\n pkts-sofar: %llu errors: %llu\n", (unsigned long long)pkt_dev->sofar, (unsigned long long)pkt_dev->errors); seq_printf(seq, " started: %lluus stopped: %lluus idle: %lluus\n", (unsigned long long) ktime_to_us(pkt_dev->started_at), (unsigned long long) ktime_to_us(stopped), (unsigned long long) idle); seq_printf(seq, " seq_num: %d cur_dst_mac_offset: %d cur_src_mac_offset: %d\n", pkt_dev->seq_num, pkt_dev->cur_dst_mac_offset, pkt_dev->cur_src_mac_offset); if (pkt_dev->flags & F_IPV6) { seq_printf(seq, " cur_saddr: %pI6c cur_daddr: %pI6c\n", &pkt_dev->cur_in6_saddr, &pkt_dev->cur_in6_daddr); } else seq_printf(seq, " cur_saddr: %pI4 cur_daddr: %pI4\n", &pkt_dev->cur_saddr, &pkt_dev->cur_daddr); seq_printf(seq, " cur_udp_dst: %d cur_udp_src: %d\n", pkt_dev->cur_udp_dst, pkt_dev->cur_udp_src); seq_printf(seq, " cur_queue_map: %u\n", pkt_dev->cur_queue_map); seq_printf(seq, " flows: %u\n", pkt_dev->nflows); if (pkt_dev->result[0]) seq_printf(seq, "Result: %s\n", pkt_dev->result); else seq_puts(seq, "Result: Idle\n"); return 0; }

Contributors

PersonTokensPropCommitsCommitProp
robert olssonrobert olsson53450.19%413.33%
francesco fondellifrancesco fondelli11610.90%26.67%
stephen hemmingerstephen hemminger10710.06%413.33%
steven whitehousesteven whitehouse827.71%13.33%
jamal hadi salimjamal hadi salim494.61%26.67%
thomas grafthomas graf363.38%26.67%
alexei starovoitovalexei starovoitov343.20%26.67%
john fastabendjohn fastabend333.10%26.67%
fan dufan du191.79%13.33%
alexey dobriyanalexey dobriyan191.79%13.33%
jesper dangaard brouerjesper dangaard brouer161.50%26.67%
joe perchesjoe perches80.75%13.33%
americo wangamerico wang30.28%13.33%
kris katterjohnkris katterjohn30.28%13.33%
eric dumazeteric dumazet20.19%26.67%
johannes bergjohannes berg20.19%13.33%
daniel borkmanndaniel borkmann10.09%13.33%
Total1064100.00%30100.00%


static int hex32_arg(const char __user *user_buffer, unsigned long maxlen, __u32 *num) { int i = 0; *num = 0; for (; i < maxlen; i++) { int value; char c; *num <<= 4; if (get_user(c, &user_buffer[i])) return -EFAULT; value = hex_to_bin(c); if (value >= 0) *num |= value; else break; } return i; }

Contributors

PersonTokensPropCommitsCommitProp
steven whitehousesteven whitehouse7782.80%133.33%
andy shevchenkoandy shevchenko1111.83%133.33%
francesco fondellifrancesco fondelli55.38%133.33%
Total93100.00%3100.00%


static int count_trail_chars(const char __user * user_buffer, unsigned int maxlen) { int i; for (i = 0; i < maxlen; i++) { char c; if (get_user(c, &user_buffer[i])) return -EFAULT; switch (c) { case '\"': case '\n': case '\r': case '\t': case ' ': case '=': break; default: goto done; } } done: return i; }

Contributors

PersonTokensPropCommitsCommitProp
robert olssonrobert olsson8798.86%150.00%
al viroal viro11.14%150.00%
Total88100.00%2100.00%


static long num_arg(const char __user *user_buffer, unsigned long maxlen, unsigned long *num) { int i; *num = 0; for (i = 0; i < maxlen; i++) { char c; if (get_user(c, &user_buffer[i])) return -EFAULT; if ((c >= '0') && (c <= '9')) { *num *= 10; *num += c - '0'; } else break; } return i; }

Contributors

PersonTokensPropCommitsCommitProp
robert olssonrobert olsson9395.88%133.33%
paul gortmakerpaul gortmaker33.09%133.33%
al viroal viro11.03%133.33%
Total97100.00%3100.00%


static int strn_len(const char __user * user_buffer, unsigned int maxlen) { int i; for (i = 0; i < maxlen; i++) { char c; if (get_user(c, &user_buffer[i])) return -EFAULT; switch (c) { case '\"': case '\n': case '\r': case '\t': case ' ': goto done_str; default: break; } } done_str: return i; }

Contributors

PersonTokensPropCommitsCommitProp
steven whitehousesteven whitehouse5665.88%125.00%
robert olssonrobert olsson2529.41%125.00%
paul gortmakerpaul gortmaker33.53%125.00%
al viroal viro11.18%125.00%
Total85100.00%4100.00%


static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev) { unsigned int n = 0; char c; ssize_t i = 0; int len; pkt_dev->nr_labels = 0; do { __u32 tmp; len = hex32_arg(&buffer[i], 8, &tmp); if (len <= 0) return len; pkt_dev->labels[n] = htonl(tmp); if (pkt_dev->labels[n] & MPLS_STACK_BOTTOM) pkt_dev->flags |= F_MPLS_RND; i += len; if (get_user(c, &buffer[i])) return -EFAULT; i++; n++; if (n >= MAX_MPLS_LABELS) return -E2BIG; } while (c == ','); pkt_dev->nr_labels = n; return i; }

Contributors

PersonTokensPropCommitsCommitProp
steven whitehousesteven whitehouse12783.01%125.00%
robert olssonrobert olsson2315.03%125.00%
francesco fondellifrancesco fondelli21.31%125.00%
eric dumazeteric dumazet10.65%125.00%
Total153100.00%4100.00%


static ssize_t