inet: frags: use rhashtables for reassembly units

IP Fragmentation:

ipfrag_high_thresh - INTEGER

	Maximum memory used to reassemble IP fragments. When

	ipfrag_high_thresh bytes of memory is allocated for this purpose,

	the fragment handler will toss packets until ipfrag_low_thresh

	is reached. This also serves as a maximum limit to namespaces

	different from the initial one.

	Maximum memory used to reassemble IP fragments.

ipfrag_low_thresh - INTEGER

	(Obsolete since linux-4.17)

	Maximum memory used to reassemble IP fragments before the kernel

	begins to remove incomplete fragment queues to free up resources.

	The kernel still accepts new fragments for defragmentation.

#ifndef __NET_FRAG_H__

#define __NET_FRAG_H__

#include <linux/rhashtable.h>

struct netns_frags {

	struct rhashtable       rhashtable ____cacheline_aligned_in_smp;

	/* Keep atomic mem on separate cachelines in structs that include it */

	atomic_t		mem ____cacheline_aligned_in_smp;

	/* sysctls */

	INET_FRAG_COMPLETE	= BIT(2),

};

struct frag_v4_compare_key {

	__be32		saddr;

	__be32		daddr;

	u32		user;

	u32		vif;

	__be16		id;

	u16		protocol;

};

struct frag_v6_compare_key {

	struct in6_addr	saddr;

	struct in6_addr	daddr;

	u32		user;

	__be32		id;

	u32		iif;

};

/**

 * struct inet_frag_queue - fragment queue

 *

 * @lock: spinlock protecting the queue

 * @node: rhash node

 * @key: keys identifying this frag.

 * @timer: queue expiration timer

 * @list: hash bucket list

 * @lock: spinlock protecting this frag

 * @refcnt: reference count of the queue

 * @fragments: received fragments head

 * @fragments_tail: received fragments tail

 * @flags: fragment queue flags

 * @max_size: maximum received fragment size

 * @net: namespace that this frag belongs to

 * @list_evictor: list of queues to forcefully evict (e.g. due to low memory)

 * @rcu: rcu head for freeing deferall

 */

struct inet_frag_queue {

	spinlock_t		lock;

	struct rhash_head	node;

	union {

		struct frag_v4_compare_key v4;

		struct frag_v6_compare_key v6;

	} key;

	struct timer_list	timer;

	struct hlist_node	list;

	spinlock_t		lock;

	refcount_t		refcnt;

	struct sk_buff		*fragments;

	struct sk_buff		*fragments_tail;

	__u8			flags;

	u16			max_size;

	struct netns_frags      *net;

	struct hlist_node	list_evictor;

};

#define INETFRAGS_HASHSZ	1024

/* averaged:

 * max_depth = default ipfrag_high_thresh / INETFRAGS_HASHSZ /

 *	       rounded up (SKB_TRUELEN(0) + sizeof(struct ipq or

 *	       struct frag_queue))

 */

#define INETFRAGS_MAXDEPTH	128

struct inet_frag_bucket {

	struct hlist_head	chain;

	spinlock_t		chain_lock;

	struct rcu_head		rcu;

};

struct inet_frags {

	struct inet_frag_bucket	hash[INETFRAGS_HASHSZ];

	struct work_struct	frags_work;

	unsigned int next_bucket;

	unsigned long last_rebuild_jiffies;

	bool rebuild;

	/* The first call to hashfn is responsible to initialize

	 * rnd. This is best done with net_get_random_once.

	 *

	 * rnd_seqlock is used to let hash insertion detect

	 * when it needs to re-lookup the hash chain to use.

	 */

	u32			rnd;

	seqlock_t		rnd_seqlock;

	unsigned int		qsize;

	unsigned int		(*hashfn)(const struct inet_frag_queue *);

	bool			(*match)(const struct inet_frag_queue *q,

					 const void *arg);

	void			(*constructor)(struct inet_frag_queue *q,

					       const void *arg);

	void			(*destructor)(struct inet_frag_queue *);

	void			(*frag_expire)(struct timer_list *t);

	struct kmem_cache	*frags_cachep;

	const char		*frags_cache_name;

	struct rhashtable_params rhash_params;

};

int inet_frags_init(struct inet_frags *);

static inline int inet_frags_init_net(struct netns_frags *nf)

{

	atomic_set(&nf->mem, 0);

	return 0;

	return rhashtable_init(&nf->rhashtable, &nf->f->rhash_params);

}

void inet_frags_exit_net(struct netns_frags *nf);

void inet_frag_kill(struct inet_frag_queue *q);

void inet_frag_destroy(struct inet_frag_queue *q);

struct inet_frag_queue *inet_frag_find(struct netns_frags *nf,

		struct inet_frags *f, void *key, unsigned int hash);

struct inet_frag_queue *inet_frag_find(struct netns_frags *nf, void *key);

void inet_frag_maybe_warn_overflow(struct inet_frag_queue *q,

				   const char *prefix);

static inline bool inet_frag_evicting(struct inet_frag_queue *q)

{

	return !hlist_unhashed(&q->list_evictor);

	return false;

}

/* Memory Tracking Functions. */

	__IP6_DEFRAG_CONNTRACK_BRIDGE_IN = IP6_DEFRAG_CONNTRACK_BRIDGE_IN + USHRT_MAX,

};

struct ip6_create_arg {

	__be32 id;

	u32 user;

	const struct in6_addr *src;

	const struct in6_addr *dst;

	int iif;

	u8 ecn;

};

void ip6_frag_init(struct inet_frag_queue *q, const void *a);

bool ip6_frag_match(const struct inet_frag_queue *q, const void *a);

extern const struct rhashtable_params ip6_rhash_params;

/*

 *	Equivalent of ipv4 struct ip

struct frag_queue {

	struct inet_frag_queue	q;

	__be32			id;		/* fragment id		*/

	u32			user;

	struct in6_addr		saddr;

	struct in6_addr		daddr;

	int			iif;

	__u16			nhoffset;

	u8			ecn;

#define LOWPAN_DISPATCH_FRAG1           0xc0

#define LOWPAN_DISPATCH_FRAGN           0xe0

struct lowpan_create_arg {

struct frag_lowpan_compare_key {

	u16 tag;

	u16 d_size;

	const struct ieee802154_addr *src;

	const struct ieee802154_addr *dst;

	const struct ieee802154_addr src;

	const struct ieee802154_addr dst;

};

/* Equivalent of ipv4 struct ip

/* Equivalent of ipv4 struct ipq

 */

struct lowpan_frag_queue {

	struct inet_frag_queue	q;

	u16			tag;

	u16			d_size;

	struct ieee802154_addr	saddr;

	struct ieee802154_addr	daddr;

};

static inline u32 ieee802154_addr_hash(const struct ieee802154_addr *a)

{

	switch (a->mode) {

	case IEEE802154_ADDR_LONG:

		return (((__force u64)a->extended_addr) >> 32) ^

			(((__force u64)a->extended_addr) & 0xffffffff);

	case IEEE802154_ADDR_SHORT:

		return (__force u32)(a->short_addr + (a->pan_id << 16));

	default:

		return 0;

	}

}

int lowpan_frag_rcv(struct sk_buff *skb, const u8 frag_type);

void lowpan_net_frag_exit(void);

int lowpan_net_frag_init(void);

static int lowpan_frag_reasm(struct lowpan_frag_queue *fq,

			     struct sk_buff *prev, struct net_device *ldev);

static unsigned int lowpan_hash_frag(u16 tag, u16 d_size,

				     const struct ieee802154_addr *saddr,

				     const struct ieee802154_addr *daddr)

{

	net_get_random_once(&lowpan_frags.rnd, sizeof(lowpan_frags.rnd));

	return jhash_3words(ieee802154_addr_hash(saddr),

			    ieee802154_addr_hash(daddr),

			    (__force u32)(tag + (d_size << 16)),

			    lowpan_frags.rnd);

}

static unsigned int lowpan_hashfn(const struct inet_frag_queue *q)

{

	const struct lowpan_frag_queue *fq;

	fq = container_of(q, struct lowpan_frag_queue, q);

	return lowpan_hash_frag(fq->tag, fq->d_size, &fq->saddr, &fq->daddr);

}

static bool lowpan_frag_match(const struct inet_frag_queue *q, const void *a)

{

	const struct lowpan_frag_queue *fq;

	const struct lowpan_create_arg *arg = a;

	fq = container_of(q, struct lowpan_frag_queue, q);

	return	fq->tag == arg->tag && fq->d_size == arg->d_size &&

		ieee802154_addr_equal(&fq->saddr, arg->src) &&

		ieee802154_addr_equal(&fq->daddr, arg->dst);

}

static void lowpan_frag_init(struct inet_frag_queue *q, const void *a)

{

	const struct lowpan_create_arg *arg = a;

	const struct frag_lowpan_compare_key *key = a;

	struct lowpan_frag_queue *fq;

	fq = container_of(q, struct lowpan_frag_queue, q);

	fq->tag = arg->tag;

	fq->d_size = arg->d_size;

	fq->saddr = *arg->src;

	fq->daddr = *arg->dst;

	BUILD_BUG_ON(sizeof(*key) > sizeof(q->key));

	memcpy(&q->key, key, sizeof(*key));

}

static void lowpan_frag_expire(struct timer_list *t)

	const struct ieee802154_addr *src,

	const struct ieee802154_addr *dst)

{

	struct inet_frag_queue *q;

	struct lowpan_create_arg arg;

	unsigned int hash;

	struct netns_ieee802154_lowpan *ieee802154_lowpan =

		net_ieee802154_lowpan(net);

	struct frag_lowpan_compare_key key = {

		.tag = cb->d_tag,

		.d_size = cb->d_size,

		.src = *src,

		.dst = *dst,

	};

	struct inet_frag_queue *q;

	arg.tag = cb->d_tag;

	arg.d_size = cb->d_size;

	arg.src = src;

	arg.dst = dst;

	hash = lowpan_hash_frag(cb->d_tag, cb->d_size, src, dst);

	q = inet_frag_find(&ieee802154_lowpan->frags,

			   &lowpan_frags, &arg, hash);

	q = inet_frag_find(&ieee802154_lowpan->frags, &key);

	if (IS_ERR_OR_NULL(q)) {

		inet_frag_maybe_warn_overflow(q, pr_fmt());

		return NULL;

	.exit = lowpan_frags_exit_net,

};

static u32 lowpan_key_hashfn(const void *data, u32 len, u32 seed)

{

	return jhash2(data,

		      sizeof(struct frag_lowpan_compare_key) / sizeof(u32), seed);

}

static u32 lowpan_obj_hashfn(const void *data, u32 len, u32 seed)

{

	const struct inet_frag_queue *fq = data;

	return jhash2((const u32 *)&fq->key,

		      sizeof(struct frag_lowpan_compare_key) / sizeof(u32), seed);

}

static int lowpan_obj_cmpfn(struct rhashtable_compare_arg *arg, const void *ptr)

{

	const struct frag_lowpan_compare_key *key = arg->key;

	const struct inet_frag_queue *fq = ptr;

	return !!memcmp(&fq->key, key, sizeof(*key));

}

static const struct rhashtable_params lowpan_rhash_params = {

	.head_offset		= offsetof(struct inet_frag_queue, node),

	.hashfn			= lowpan_key_hashfn,

	.obj_hashfn		= lowpan_obj_hashfn,

	.obj_cmpfn		= lowpan_obj_cmpfn,

	.automatic_shrinking	= true,

};

int __init lowpan_net_frag_init(void)

{

	int ret;

	lowpan_frags.hashfn = lowpan_hashfn;

	lowpan_frags.constructor = lowpan_frag_init;

	lowpan_frags.destructor = NULL;

	lowpan_frags.qsize = sizeof(struct frag_queue);

	lowpan_frags.match = lowpan_frag_match;

	lowpan_frags.frag_expire = lowpan_frag_expire;

	lowpan_frags.frags_cache_name = lowpan_frags_cache_name;

	lowpan_frags.rhash_params = lowpan_rhash_params;

	ret = inet_frags_init(&lowpan_frags);

	if (ret)

		goto out;