[mirror_ubuntu-artful-kernel.git] / include / linux / skb_array.h

/*
 *	Definitions for the 'struct skb_array' datastructure.
 *
 *	Author:
 *		Michael S. Tsirkin <mst@redhat.com>
 *
 *	Copyright (C) 2016 Red Hat, Inc.
 *
 *	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.
 *
 *	Limited-size FIFO of skbs. Can be used more or less whenever
 *	sk_buff_head can be used, except you need to know the queue size in
 *	advance.
 *	Implemented as a type-safe wrapper around ptr_ring.
 */

#ifndef _LINUX_SKB_ARRAY_H
#define _LINUX_SKB_ARRAY_H 1

#ifdef __KERNEL__
#include <linux/ptr_ring.h>
#include <linux/skbuff.h>
#include <linux/if_vlan.h>
#endif

struct skb_array {
	struct ptr_ring ring;
};

/* Might be slightly faster than skb_array_full below, but callers invoking
 * this in a loop must use a compiler barrier, for example cpu_relax().
 */
static inline bool __skb_array_full(struct skb_array *a)
{
	return __ptr_ring_full(&a->ring);
}

static inline bool skb_array_full(struct skb_array *a)
{
	return ptr_ring_full(&a->ring);
}

static inline int skb_array_produce(struct skb_array *a, struct sk_buff *skb)
{
	return ptr_ring_produce(&a->ring, skb);
}

static inline int skb_array_produce_irq(struct skb_array *a, struct sk_buff *skb)
{
	return ptr_ring_produce_irq(&a->ring, skb);
}

static inline int skb_array_produce_bh(struct skb_array *a, struct sk_buff *skb)
{
	return ptr_ring_produce_bh(&a->ring, skb);
}

static inline int skb_array_produce_any(struct skb_array *a, struct sk_buff *skb)
{
	return ptr_ring_produce_any(&a->ring, skb);
}

/* Might be slightly faster than skb_array_empty below, but only safe if the
 * array is never resized. Also, callers invoking this in a loop must take care
 * to use a compiler barrier, for example cpu_relax().
 */
static inline bool __skb_array_empty(struct skb_array *a)
{
	return !__ptr_ring_peek(&a->ring);
}

static inline bool skb_array_empty(struct skb_array *a)
{
	return ptr_ring_empty(&a->ring);
}

static inline bool skb_array_empty_bh(struct skb_array *a)
{
	return ptr_ring_empty_bh(&a->ring);
}

static inline bool skb_array_empty_irq(struct skb_array *a)
{
	return ptr_ring_empty_irq(&a->ring);
}

static inline bool skb_array_empty_any(struct skb_array *a)
{
	return ptr_ring_empty_any(&a->ring);
}

static inline struct sk_buff *skb_array_consume(struct skb_array *a)
{
	return ptr_ring_consume(&a->ring);
}

static inline struct sk_buff *skb_array_consume_irq(struct skb_array *a)
{
	return ptr_ring_consume_irq(&a->ring);
}

static inline struct sk_buff *skb_array_consume_any(struct skb_array *a)
{
	return ptr_ring_consume_any(&a->ring);
}

static inline struct sk_buff *skb_array_consume_bh(struct skb_array *a)
{
	return ptr_ring_consume_bh(&a->ring);
}

static inline int __skb_array_len_with_tag(struct sk_buff *skb)
{
	if (likely(skb)) {
		int len = skb->len;

		if (skb_vlan_tag_present(skb))
			len += VLAN_HLEN;

		return len;
	} else {
		return 0;
	}
}

static inline int skb_array_peek_len(struct skb_array *a)
{
	return PTR_RING_PEEK_CALL(&a->ring, __skb_array_len_with_tag);
}

static inline int skb_array_peek_len_irq(struct skb_array *a)
{
	return PTR_RING_PEEK_CALL_IRQ(&a->ring, __skb_array_len_with_tag);
}

static inline int skb_array_peek_len_bh(struct skb_array *a)
{
	return PTR_RING_PEEK_CALL_BH(&a->ring, __skb_array_len_with_tag);
}

static inline int skb_array_peek_len_any(struct skb_array *a)
{
	return PTR_RING_PEEK_CALL_ANY(&a->ring, __skb_array_len_with_tag);
}

static inline int skb_array_init(struct skb_array *a, int size, gfp_t gfp)
{
	return ptr_ring_init(&a->ring, size, gfp);
}

static void __skb_array_destroy_skb(void *ptr)
{
	kfree_skb(ptr);
}

static inline int skb_array_resize(struct skb_array *a, int size, gfp_t gfp)
{
	return ptr_ring_resize(&a->ring, size, gfp, __skb_array_destroy_skb);
}

static inline int skb_array_resize_multiple(struct skb_array **rings,
					    int nrings, int size, gfp_t gfp)
{
	BUILD_BUG_ON(offsetof(struct skb_array, ring));
	return ptr_ring_resize_multiple((struct ptr_ring **)rings,
					nrings, size, gfp,
					__skb_array_destroy_skb);
}

static inline void skb_array_cleanup(struct skb_array *a)
{
	ptr_ring_cleanup(&a->ring, __skb_array_destroy_skb);
}

#endif /* _LINUX_SKB_ARRAY_H  */
Commit	Line	Data
ad69f35d MT	1	/*
	2	* Definitions for the 'struct skb_array' datastructure.
	3	*
	4	* Author:
	5	* Michael S. Tsirkin <mst@redhat.com>
	6	*
	7	* Copyright (C) 2016 Red Hat, Inc.
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*
	14	* Limited-size FIFO of skbs. Can be used more or less whenever
	15	* sk_buff_head can be used, except you need to know the queue size in
	16	* advance.
	17	* Implemented as a type-safe wrapper around ptr_ring.
	18	*/
	19
	20	#ifndef _LINUX_SKB_ARRAY_H
	21	#define _LINUX_SKB_ARRAY_H 1
	22
	23	#ifdef __KERNEL__
	24	#include <linux/ptr_ring.h>
	25	#include <linux/skbuff.h>
	26	#include <linux/if_vlan.h>
	27	#endif
	28
	29	struct skb_array {
	30	struct ptr_ring ring;
	31	};
	32
	33	/* Might be slightly faster than skb_array_full below, but callers invoking
	34	* this in a loop must use a compiler barrier, for example cpu_relax().
	35	*/
	36	static inline bool __skb_array_full(struct skb_array *a)
	37	{
	38	return __ptr_ring_full(&a->ring);
	39	}
	40
	41	static inline bool skb_array_full(struct skb_array *a)
	42	{
	43	return ptr_ring_full(&a->ring);
	44	}
	45
	46	static inline int skb_array_produce(struct skb_array a, struct sk_buff skb)
	47	{
	48	return ptr_ring_produce(&a->ring, skb);
	49	}
	50
	51	static inline int skb_array_produce_irq(struct skb_array a, struct sk_buff skb)
	52	{
	53	return ptr_ring_produce_irq(&a->ring, skb);
	54	}
	55
	56	static inline int skb_array_produce_bh(struct skb_array a, struct sk_buff skb)
	57	{
	58	return ptr_ring_produce_bh(&a->ring, skb);
	59	}
	60
	61	static inline int skb_array_produce_any(struct skb_array a, struct sk_buff skb)
	62	{
	63	return ptr_ring_produce_any(&a->ring, skb);
	64	}
65
7d7072e3 MT	66	/* Might be slightly faster than skb_array_empty below, but only safe if the
	67	* array is never resized. Also, callers invoking this in a loop must take care
	68	* to use a compiler barrier, for example cpu_relax().
ad69f35d MT	69	*/
	70	static inline bool __skb_array_empty(struct skb_array *a)
	71	{
	72	return !__ptr_ring_peek(&a->ring);
	73	}
	74
	75	static inline bool skb_array_empty(struct skb_array *a)
	76	{
	77	return ptr_ring_empty(&a->ring);
	78	}
	79
7d7072e3 MT	80	static inline bool skb_array_empty_bh(struct skb_array *a)
	81	{
	82	return ptr_ring_empty_bh(&a->ring);
	83	}
	84
	85	static inline bool skb_array_empty_irq(struct skb_array *a)
	86	{
	87	return ptr_ring_empty_irq(&a->ring);
	88	}
	89
	90	static inline bool skb_array_empty_any(struct skb_array *a)
	91	{
	92	return ptr_ring_empty_any(&a->ring);
	93	}
	94
ad69f35d MT	95	static inline struct sk_buff skb_array_consume(struct skb_array a)
	96	{
	97	return ptr_ring_consume(&a->ring);
	98	}
	99
	100	static inline struct sk_buff skb_array_consume_irq(struct skb_array a)
	101	{
	102	return ptr_ring_consume_irq(&a->ring);
	103	}
	104
	105	static inline struct sk_buff skb_array_consume_any(struct skb_array a)
	106	{
	107	return ptr_ring_consume_any(&a->ring);
	108	}
	109
	110	static inline struct sk_buff skb_array_consume_bh(struct skb_array a)
	111	{
	112	return ptr_ring_consume_bh(&a->ring);
	113	}
	114
	115	static inline int __skb_array_len_with_tag(struct sk_buff *skb)
	116	{
	117	if (likely(skb)) {
	118	int len = skb->len;
	119
	120	if (skb_vlan_tag_present(skb))
	121	len += VLAN_HLEN;
	122
	123	return len;
	124	} else {
	125	return 0;
	126	}
	127	}
	128
	129	static inline int skb_array_peek_len(struct skb_array *a)
	130	{
	131	return PTR_RING_PEEK_CALL(&a->ring, __skb_array_len_with_tag);
	132	}
	133
	134	static inline int skb_array_peek_len_irq(struct skb_array *a)
	135	{
	136	return PTR_RING_PEEK_CALL_IRQ(&a->ring, __skb_array_len_with_tag);
	137	}
	138
	139	static inline int skb_array_peek_len_bh(struct skb_array *a)
	140	{
	141	return PTR_RING_PEEK_CALL_BH(&a->ring, __skb_array_len_with_tag);
	142	}
	143
	144	static inline int skb_array_peek_len_any(struct skb_array *a)
	145	{
	146	return PTR_RING_PEEK_CALL_ANY(&a->ring, __skb_array_len_with_tag);
	147	}
	148
	149	static inline int skb_array_init(struct skb_array *a, int size, gfp_t gfp)
	150	{
	151	return ptr_ring_init(&a->ring, size, gfp);
	152	}
	153
fd68adec	154	static void __skb_array_destroy_skb(void *ptr)
7d7072e3 MT	155	{
	156	kfree_skb(ptr);
	157	}
	158
fd68adec	159	static inline int skb_array_resize(struct skb_array *a, int size, gfp_t gfp)
7d7072e3 MT	160	{
	161	return ptr_ring_resize(&a->ring, size, gfp, __skb_array_destroy_skb);
	162	}
	163
bf900b3d JW	164	static inline int skb_array_resize_multiple(struct skb_array **rings,
	165	int nrings, int size, gfp_t gfp)
	166	{
	167	BUILD_BUG_ON(offsetof(struct skb_array, ring));
	168	return ptr_ring_resize_multiple((struct ptr_ring **)rings,
	169	nrings, size, gfp,
	170	__skb_array_destroy_skb);
	171	}
	172
ad69f35d MT	173	static inline void skb_array_cleanup(struct skb_array *a)
ad69f35d MT	174	{
7d7072e3	175	ptr_ring_cleanup(&a->ring, __skb_array_destroy_skb);
ad69f35d MT	176	}
	177
	178	#endif /* _LINUX_SKB_ARRAY_H */