[mirror_ubuntu-jammy-kernel.git] / net / netfilter / nf_conntrack_extend.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Structure dynamic extension infrastructure
 * Copyright (C) 2004 Rusty Russell IBM Corporation
 * Copyright (C) 2007 Netfilter Core Team <coreteam@netfilter.org>
 * Copyright (C) 2007 USAGI/WIDE Project <http://www.linux-ipv6.org>
 */
#include <linux/kernel.h>
#include <linux/kmemleak.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/rcupdate.h>
#include <linux/slab.h>
#include <linux/skbuff.h>
#include <net/netfilter/nf_conntrack_extend.h>

static struct nf_ct_ext_type __rcu *nf_ct_ext_types[NF_CT_EXT_NUM];
static DEFINE_MUTEX(nf_ct_ext_type_mutex);
#define NF_CT_EXT_PREALLOC	128u /* conntrack events are on by default */

void nf_ct_ext_destroy(struct nf_conn *ct)
{
	unsigned int i;
	struct nf_ct_ext_type *t;

	for (i = 0; i < NF_CT_EXT_NUM; i++) {
		rcu_read_lock();
		t = rcu_dereference(nf_ct_ext_types[i]);

		/* Here the nf_ct_ext_type might have been unregisterd.
		 * I.e., it has responsible to cleanup private
		 * area in all conntracks when it is unregisterd.
		 */
		if (t && t->destroy)
			t->destroy(ct);
		rcu_read_unlock();
	}

	kfree(ct->ext);
}

void *nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_t gfp)
{
	unsigned int newlen, newoff, oldlen, alloc;
	struct nf_ct_ext_type *t;
	struct nf_ct_ext *new;

	/* Conntrack must not be confirmed to avoid races on reallocation. */
	WARN_ON(nf_ct_is_confirmed(ct));


	if (ct->ext) {
		const struct nf_ct_ext *old = ct->ext;

		if (__nf_ct_ext_exist(old, id))
			return NULL;
		oldlen = old->len;
	} else {
		oldlen = sizeof(*new);
	}

	rcu_read_lock();
	t = rcu_dereference(nf_ct_ext_types[id]);
	if (!t) {
		rcu_read_unlock();
		return NULL;
	}

	newoff = ALIGN(oldlen, t->align);
	newlen = newoff + t->len;
	rcu_read_unlock();

	alloc = max(newlen, NF_CT_EXT_PREALLOC);
	new = krealloc(ct->ext, alloc, gfp);
	if (!new)
		return NULL;

	if (!ct->ext)
		memset(new->offset, 0, sizeof(new->offset));

	new->offset[id] = newoff;
	new->len = newlen;
	memset((void *)new + newoff, 0, newlen - newoff);

	ct->ext = new;
	return (void *)new + newoff;
}
EXPORT_SYMBOL(nf_ct_ext_add);

/* This MUST be called in process context. */
int nf_ct_extend_register(const struct nf_ct_ext_type *type)
{
	int ret = 0;

	mutex_lock(&nf_ct_ext_type_mutex);
	if (nf_ct_ext_types[type->id]) {
		ret = -EBUSY;
		goto out;
	}

	rcu_assign_pointer(nf_ct_ext_types[type->id], type);
out:
	mutex_unlock(&nf_ct_ext_type_mutex);
	return ret;
}
EXPORT_SYMBOL_GPL(nf_ct_extend_register);

/* This MUST be called in process context. */
void nf_ct_extend_unregister(const struct nf_ct_ext_type *type)
{
	mutex_lock(&nf_ct_ext_type_mutex);
	RCU_INIT_POINTER(nf_ct_ext_types[type->id], NULL);
	mutex_unlock(&nf_ct_ext_type_mutex);
	synchronize_rcu();
}
EXPORT_SYMBOL_GPL(nf_ct_extend_unregister);
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
ecfab2c9 YK	2	/* Structure dynamic extension infrastructure
	3	* Copyright (C) 2004 Rusty Russell IBM Corporation
	4	* Copyright (C) 2007 Netfilter Core Team <coreteam@netfilter.org>
	5	* Copyright (C) 2007 USAGI/WIDE Project <http://www.linux-ipv6.org>
ecfab2c9 YK	6	*/
ecfab2c9 YK	7	#include <linux/kernel.h>
765cca91	8	#include <linux/kmemleak.h>
ecfab2c9 YK	9	#include <linux/module.h>
	10	#include <linux/mutex.h>
	11	#include <linux/rcupdate.h>
	12	#include <linux/slab.h>
	13	#include <linux/skbuff.h>
	14	#include <net/netfilter/nf_conntrack_extend.h>
	15
0906a372	16	static struct nf_ct_ext_type __rcu *nf_ct_ext_types[NF_CT_EXT_NUM];
ecfab2c9	17	static DEFINE_MUTEX(nf_ct_ext_type_mutex);
54044b1f	18	#define NF_CT_EXT_PREALLOC 128u /* conntrack events are on by default */
ecfab2c9	19
8eeef235	20	void nf_ct_ext_destroy(struct nf_conn *ct)
ecfab2c9 YK	21	{
	22	unsigned int i;
	23	struct nf_ct_ext_type *t;
	24
	25	for (i = 0; i < NF_CT_EXT_NUM; i++) {
ecfab2c9 YK	26	rcu_read_lock();
	27	t = rcu_dereference(nf_ct_ext_types[i]);
	28
	29	/* Here the nf_ct_ext_type might have been unregisterd.
	30	* I.e., it has responsible to cleanup private
	31	* area in all conntracks when it is unregisterd.
	32	*/
	33	if (t && t->destroy)
	34	t->destroy(ct);
	35	rcu_read_unlock();
	36	}
2ad9d774 FW	37
2ad9d774 FW	38	kfree(ct->ext);
ecfab2c9	39	}
ecfab2c9	40
faec865d	41	void nf_ct_ext_add(struct nf_conn ct, enum nf_ct_ext_id id, gfp_t gfp)
ecfab2c9	42	{
22d4536d	43	unsigned int newlen, newoff, oldlen, alloc;
ecfab2c9	44	struct nf_ct_ext_type *t;
2ad9d774	45	struct nf_ct_ext *new;
ecfab2c9	46
55871d04	47	/* Conntrack must not be confirmed to avoid races on reallocation. */
44d6e2f2	48	WARN_ON(nf_ct_is_confirmed(ct));
55871d04	49
ecfab2c9	50
2ad9d774 FW	51	if (ct->ext) {
	52	const struct nf_ct_ext *old = ct->ext;
	53
22d4536d FW	54	if (__nf_ct_ext_exist(old, id))
	55	return NULL;
	56	oldlen = old->len;
	57	} else {
	58	oldlen = sizeof(*new);
	59	}
ecfab2c9 YK	60
	61	rcu_read_lock();
	62	t = rcu_dereference(nf_ct_ext_types[id]);
9c3f3794 LZ	63	if (!t) {
	64	rcu_read_unlock();
	65	return NULL;
	66	}
ecfab2c9	67
22d4536d	68	newoff = ALIGN(oldlen, t->align);
faec865d	69	newlen = newoff + t->len;
ecfab2c9 YK	70	rcu_read_unlock();
ecfab2c9 YK	71
22d4536d	72	alloc = max(newlen, NF_CT_EXT_PREALLOC);
2ad9d774	73	new = krealloc(ct->ext, alloc, gfp);
31d8519c PE	74	if (!new)
31d8519c PE	75	return NULL;
ecfab2c9	76
2ad9d774	77	if (!ct->ext)
22d4536d	78	memset(new->offset, 0, sizeof(new->offset));
ecfab2c9	79
6c64825b PM	80	new->offset[id] = newoff;
	81	new->len = newlen;
	82	memset((void *)new + newoff, 0, newlen - newoff);
2ad9d774 FW	83
2ad9d774 FW	84	ct->ext = new;
6c64825b	85	return (void *)new + newoff;
ecfab2c9	86	}
faec865d	87	EXPORT_SYMBOL(nf_ct_ext_add);
ecfab2c9	88
ecfab2c9	89	/* This MUST be called in process context. */
23f671a1	90	int nf_ct_extend_register(const struct nf_ct_ext_type *type)
ecfab2c9 YK	91	{
	92	int ret = 0;
	93
	94	mutex_lock(&nf_ct_ext_type_mutex);
	95	if (nf_ct_ext_types[type->id]) {
	96	ret = -EBUSY;
	97	goto out;
	98	}
	99
cf778b00	100	rcu_assign_pointer(nf_ct_ext_types[type->id], type);
ecfab2c9 YK	101	out:
	102	mutex_unlock(&nf_ct_ext_type_mutex);
	103	return ret;
	104	}
	105	EXPORT_SYMBOL_GPL(nf_ct_extend_register);
	106
	107	/* This MUST be called in process context. */
23f671a1	108	void nf_ct_extend_unregister(const struct nf_ct_ext_type *type)
ecfab2c9 YK	109	{
ecfab2c9 YK	110	mutex_lock(&nf_ct_ext_type_mutex);
a9b3cd7f	111	RCU_INIT_POINTER(nf_ct_ext_types[type->id], NULL);
ecfab2c9	112	mutex_unlock(&nf_ct_ext_type_mutex);
9c3f3794	113	synchronize_rcu();
ecfab2c9 YK	114	}
ecfab2c9 YK	115	EXPORT_SYMBOL_GPL(nf_ct_extend_unregister);