Commit 445af0d2 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'pktgen-imix' 

Nick Richardson says:

====================
pktgen: Add IMIX mode

Adds internet mix (IMIX) mode to pktgen. Internet mix is
included in many user-space network perf testing tools. It allows
for the user to specify a distribution of discrete packet sizes to be
generated. This type of test is common among vendors when perf testing
their devices.
[RFC link: https://datatracker.ietf.org/doc/html/rfc2544#section-9.1

]

This allows users to get a
more complete picture of how their device will perform in the
real-world.

This feature adds a command that allows users to specify an imix
distribution in the following format:
  imix_weights size_1,weight_1 size_2,weight_2 ... size_n,weight_n

The distribution of packets with size_i will be
(weight_i / total_weights) where
total_weights = weight_1 + weight_2 + ... + weight_n

For example:
  imix_weights 40,7 576,4 1500,1

The pkt_size "40" will account for 7 / (7 + 4 + 1) = ~58% of the total
packets sent.

This patch was tested with the following:
1. imix_weights = 40,7 576,4 1500,1
2. imix_weights = 0,7 576,4 1500,1
  - Packet size of 0 is resized to the minimum, 42
3. imix_weights = 40,7 576,4 1500,1 count = 0
  - Zero count.
  - Runs until user stops pktgen.
Invalid Configurations
1. clone_skb = 200 imix_weights = 40,7 576,4 1500,1
    - Returns error code -524 (-ENOTSUPP) when setting imix_weights
2. len(imix_weights) > MAX_IMIX_ENTRIES
    - Returns -7 (-E2BIG)

This patch is split into three parts, each provide different aspects of
required functionality:
  1. Parse internet mix input.
  2. Add IMIX Distribution representation.
  3. Process and output IMIX results.

Changes in v2:
* Remove __ prefix outside of uAPI.
* Use seq_puts instead of seq_printf where necessary.
* Reorder variable declaration.
* Return -EINVAL instead of -ENOTSUPP when using IMIX with clone_skb > 0
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 6c4110d9 769afb3f

net/core/pktgen.c

+162 −1
Original line number Diff line number Diff line
@@ -175,6 +175,9 @@ 
#define IP_NAME_SZ 32

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

#define MPLS_STACK_BOTTOM htonl(0x00000100)

/* Max number of internet mix entries that can be specified in imix_weights. */

#define MAX_IMIX_ENTRIES 20

#define IMIX_PRECISION 100 /* Precision of IMIX distribution */



#define func_enter() pr_debug("entering %s\n", __func__);
@@ -242,6 +245,12 @@ static char *pkt_flag_names[] = { 
#define VLAN_TAG_SIZE(x) ((x)->vlan_id == 0xffff ? 0 : 4)

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



struct imix_pkt {

	u64 size;

	u64 weight;

	u64 count_so_far;

};



struct flow_state {

	__be32 cur_daddr;

	int count;
@@ -343,6 +352,12 @@ struct pktgen_dev { 
	__u8 traffic_class;  /* ditto for the (former) Traffic Class in IPv6

				(see RFC 3260, sec. 4) */



	/* IMIX */

	unsigned int n_imix_entries;

	struct imix_pkt imix_entries[MAX_IMIX_ENTRIES];

	/* Maps 0-IMIX_PRECISION range to imix_entry based on probability*/

	__u8 imix_distribution[IMIX_PRECISION];



	/* MPLS */

	unsigned int nr_labels;	/* Depth of stack, 0 = no MPLS */

	__be32 labels[MAX_MPLS_LABELS];
@@ -471,6 +486,7 @@ static void pktgen_stop_all_threads(struct pktgen_net *pn); 


static void pktgen_stop(struct pktgen_thread *t);

static void pktgen_clear_counters(struct pktgen_dev *pkt_dev);

static void fill_imix_distribution(struct pktgen_dev *pkt_dev);



/* Module parameters, defaults. */

static int pg_count_d __read_mostly = 1000;
@@ -552,6 +568,16 @@ static int pktgen_if_show(struct seq_file *seq, void *v) 
		   (unsigned long long)pkt_dev->count, pkt_dev->min_pkt_size,

		   pkt_dev->max_pkt_size);



	if (pkt_dev->n_imix_entries > 0) {

		seq_puts(seq, "     imix_weights: ");

		for (i = 0; i < pkt_dev->n_imix_entries; i++) {

			seq_printf(seq, "%llu,%llu ",

				   pkt_dev->imix_entries[i].size,

				   pkt_dev->imix_entries[i].weight);

		}

		seq_puts(seq, "\n");

	}



	seq_printf(seq,

		   "     frags: %d  delay: %llu  clone_skb: %d  ifname: %s\n",

		   pkt_dev->nfrags, (unsigned long long) pkt_dev->delay,
@@ -669,6 +695,18 @@ static int pktgen_if_show(struct seq_file *seq, void *v) 
		   (unsigned long long)pkt_dev->sofar,

		   (unsigned long long)pkt_dev->errors);



	if (pkt_dev->n_imix_entries > 0) {

		int i;



		seq_puts(seq, "     imix_size_counts: ");

		for (i = 0; i < pkt_dev->n_imix_entries; i++) {

			seq_printf(seq, "%llu,%llu ",

				   pkt_dev->imix_entries[i].size,

				   pkt_dev->imix_entries[i].count_so_far);

		}

		seq_puts(seq, "\n");

	}



	seq_printf(seq,

		   "     started: %lluus  stopped: %lluus idle: %lluus\n",

		   (unsigned long long) ktime_to_us(pkt_dev->started_at),
@@ -792,6 +830,62 @@ static int strn_len(const char __user * user_buffer, unsigned int maxlen) 
	return i;

}



/* Parses imix entries from user buffer.

 * The user buffer should consist of imix entries separated by spaces

 * where each entry consists of size and weight delimited by commas.

 * "size1,weight_1 size2,weight_2 ... size_n,weight_n" for example.

 */

static ssize_t get_imix_entries(const char __user *buffer,

				struct pktgen_dev *pkt_dev)

{

	const int max_digits = 10;

	int i = 0;

	long len;

	char c;



	pkt_dev->n_imix_entries = 0;



	do {

		unsigned long weight;

		unsigned long size;



		len = num_arg(&buffer[i], max_digits, &size);

		if (len < 0)

			return len;

		i += len;

		if (get_user(c, &buffer[i]))

			return -EFAULT;

		/* Check for comma between size_i and weight_i */

		if (c != ',')

			return -EINVAL;

		i++;



		if (size < 14 + 20 + 8)

			size = 14 + 20 + 8;



		len = num_arg(&buffer[i], max_digits, &weight);

		if (len < 0)

			return len;

		if (weight <= 0)

			return -EINVAL;



		pkt_dev->imix_entries[pkt_dev->n_imix_entries].size = size;

		pkt_dev->imix_entries[pkt_dev->n_imix_entries].weight = weight;



		i += len;

		if (get_user(c, &buffer[i]))

			return -EFAULT;



		i++;

		pkt_dev->n_imix_entries++;



		if (pkt_dev->n_imix_entries > MAX_IMIX_ENTRIES)

			return -E2BIG;

	} while (c == ' ');



	return i;

}



static ssize_t get_labels(const char __user *buffer, struct pktgen_dev *pkt_dev)

{

	unsigned int n = 0;
@@ -960,6 +1054,20 @@ static ssize_t pktgen_if_write(struct file *file, 
		return count;

	}



	if (!strcmp(name, "imix_weights")) {

		if (pkt_dev->clone_skb > 0)

			return -EINVAL;



		len = get_imix_entries(&user_buffer[i], pkt_dev);

		if (len < 0)

			return len;



		fill_imix_distribution(pkt_dev);



		i += len;

		return count;

	}



	if (!strcmp(name, "debug")) {

		len = num_arg(&user_buffer[i], 10, &value);

		if (len < 0)
@@ -1082,10 +1190,16 @@ static ssize_t pktgen_if_write(struct file *file, 
		len = num_arg(&user_buffer[i], 10, &value);

		if (len < 0)

			return len;

		/* clone_skb is not supported for netif_receive xmit_mode and

		 * IMIX mode.

		 */

		if ((value > 0) &&

		    ((pkt_dev->xmit_mode == M_NETIF_RECEIVE) ||

		     !(pkt_dev->odev->priv_flags & IFF_TX_SKB_SHARING)))

			return -ENOTSUPP;

		if (value > 0 && pkt_dev->n_imix_entries > 0)

			return -EINVAL;



		i += len;

		pkt_dev->clone_skb = value;
@@ -2472,6 +2586,14 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev) 
				t = pkt_dev->min_pkt_size;

		}

		pkt_dev->cur_pkt_size = t;

	} else if (pkt_dev->n_imix_entries > 0) {

		struct imix_pkt *entry;

		__u32 t = prandom_u32() % IMIX_PRECISION;

		__u8 entry_index = pkt_dev->imix_distribution[t];



		entry = &pkt_dev->imix_entries[entry_index];

		entry->count_so_far++;

		pkt_dev->cur_pkt_size = entry->size;

	}



	set_cur_queue_map(pkt_dev);
@@ -2540,6 +2662,33 @@ static void free_SAs(struct pktgen_dev *pkt_dev) 
	}

}



static void fill_imix_distribution(struct pktgen_dev *pkt_dev)

{

	int cumulative_probabilites[MAX_IMIX_ENTRIES];

	int j = 0;

	__u64 cumulative_prob = 0;

	__u64 total_weight = 0;

	int i = 0;



	for (i = 0; i < pkt_dev->n_imix_entries; i++)

		total_weight += pkt_dev->imix_entries[i].weight;



	/* Fill cumulative_probabilites with sum of normalized probabilities */

	for (i = 0; i < pkt_dev->n_imix_entries - 1; i++) {

		cumulative_prob += div64_u64(pkt_dev->imix_entries[i].weight *

						     IMIX_PRECISION,

					     total_weight);

		cumulative_probabilites[i] = cumulative_prob;

	}

	cumulative_probabilites[pkt_dev->n_imix_entries - 1] = 100;



	for (i = 0; i < IMIX_PRECISION; i++) {

		if (i == cumulative_probabilites[j])

			j++;

		pkt_dev->imix_distribution[i] = j;

	}

}



static int process_ipsec(struct pktgen_dev *pkt_dev,

			      struct sk_buff *skb, __be16 protocol)

{
@@ -3140,7 +3289,19 @@ static void show_results(struct pktgen_dev *pkt_dev, int nr_frags) 
	pps = div64_u64(pkt_dev->sofar * NSEC_PER_SEC,

			ktime_to_ns(elapsed));



	if (pkt_dev->n_imix_entries > 0) {

		int i;

		struct imix_pkt *entry;



		bps = 0;

		for (i = 0; i < pkt_dev->n_imix_entries; i++) {

			entry = &pkt_dev->imix_entries[i];

			bps += entry->size * entry->count_so_far;

		}

		bps = div64_u64(bps * 8 * NSEC_PER_SEC, ktime_to_ns(elapsed));

	} else {

		bps = pps * 8 * pkt_dev->cur_pkt_size;

	}



	mbps = bps;

	do_div(mbps, 1000000);