[thirdparty/ipset.git] / kernel / net / netfilter / ipset / ip_set_bitmap_gen.h

/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@netfilter.org>
 */

#ifndef __IP_SET_BITMAP_IP_GEN_H
#define __IP_SET_BITMAP_IP_GEN_H

#define mtype_do_test		IPSET_TOKEN(MTYPE, _do_test)
#define mtype_gc_test		IPSET_TOKEN(MTYPE, _gc_test)
#define mtype_is_filled		IPSET_TOKEN(MTYPE, _is_filled)
#define mtype_do_add		IPSET_TOKEN(MTYPE, _do_add)
#define mtype_ext_cleanup	IPSET_TOKEN(MTYPE, _ext_cleanup)
#define mtype_do_del		IPSET_TOKEN(MTYPE, _do_del)
#define mtype_do_list		IPSET_TOKEN(MTYPE, _do_list)
#define mtype_do_head		IPSET_TOKEN(MTYPE, _do_head)
#define mtype_adt_elem		IPSET_TOKEN(MTYPE, _adt_elem)
#define mtype_add_timeout	IPSET_TOKEN(MTYPE, _add_timeout)
#define mtype_gc_init		IPSET_TOKEN(MTYPE, _gc_init)
#define mtype_kadt		IPSET_TOKEN(MTYPE, _kadt)
#define mtype_uadt		IPSET_TOKEN(MTYPE, _uadt)
#define mtype_destroy		IPSET_TOKEN(MTYPE, _destroy)
#define mtype_memsize		IPSET_TOKEN(MTYPE, _memsize)
#define mtype_flush		IPSET_TOKEN(MTYPE, _flush)
#define mtype_head		IPSET_TOKEN(MTYPE, _head)
#define mtype_same_set		IPSET_TOKEN(MTYPE, _same_set)
#define mtype_elem		IPSET_TOKEN(MTYPE, _elem)
#define mtype_test		IPSET_TOKEN(MTYPE, _test)
#define mtype_add		IPSET_TOKEN(MTYPE, _add)
#define mtype_del		IPSET_TOKEN(MTYPE, _del)
#define mtype_list		IPSET_TOKEN(MTYPE, _list)
#define mtype_gc		IPSET_TOKEN(MTYPE, _gc)
#define mtype_cancel_gc		IPSET_TOKEN(MTYPE, _cancel_gc)
#define mtype			MTYPE

#define get_ext(set, map, id)	((map)->extensions + ((set)->dsize * (id)))

static void
mtype_gc_init(struct ip_set *set, void (*gc)(GC_ARG))
{
	struct mtype *map = set->data;

	TIMER_SETUP(&map->gc, gc);
	mod_timer(&map->gc, jiffies + IPSET_GC_PERIOD(set->timeout) * HZ);
}

static void
mtype_ext_cleanup(struct ip_set *set)
{
	struct mtype *map = set->data;
	u32 id;

	for (id = 0; id < map->elements; id++)
		if (test_bit(id, map->members))
			ip_set_ext_destroy(set, get_ext(set, map, id));
}

static void
mtype_destroy(struct ip_set *set)
{
	struct mtype *map = set->data;

	if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
		mtype_ext_cleanup(set);
	ip_set_free(map->members);
	ip_set_free(map);

	set->data = NULL;
}

static void
mtype_flush(struct ip_set *set)
{
	struct mtype *map = set->data;

	if (set->extensions & IPSET_EXT_DESTROY)
		mtype_ext_cleanup(set);
	bitmap_zero(map->members, map->elements);
	set->elements = 0;
	set->ext_size = 0;
}

/* Calculate the actual memory size of the set data */
static size_t
mtype_memsize(const struct mtype *map, size_t dsize)
{
	size_t memsize = sizeof(*map) +
			 map->memsize +
			 map->elements * dsize;
	return memsize;
}

static int
mtype_head(struct ip_set *set, struct sk_buff *skb)
{
	const struct mtype *map = set->data;
	struct nlattr *nested;
	size_t memsize = mtype_memsize(map, set->dsize) + set->ext_size;

	nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
	if (!nested)
		goto nla_put_failure;
	if (mtype_do_head(skb, map) ||
	    nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref)) ||
	    nla_put_net32(skb, IPSET_ATTR_MEMSIZE, htonl(memsize)) ||
	    nla_put_net32(skb, IPSET_ATTR_ELEMENTS, htonl(set->elements)))
		goto nla_put_failure;
	if (unlikely(ip_set_put_flags(skb, set)))
		goto nla_put_failure;
	ipset_nest_end(skb, nested);

	return 0;
nla_put_failure:
	return -EMSGSIZE;
}

static int
mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
	   struct ip_set_ext *mext, u32 flags)
{
	struct mtype *map = set->data;
	const struct mtype_adt_elem *e = value;
	void *x = get_ext(set, map, e->id);
	int ret = mtype_do_test(e, map, set->dsize);

	if (ret <= 0)
		return ret;
	return ip_set_match_extensions(set, ext, mext, flags, x);
}

static int
mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
	  struct ip_set_ext *mext, u32 flags)
{
	struct mtype *map = set->data;
	const struct mtype_adt_elem *e = value;
	void *x = get_ext(set, map, e->id);
	int ret = mtype_do_add(e, map, flags, set->dsize);

	if (ret == IPSET_ADD_FAILED) {
		if (SET_WITH_TIMEOUT(set) &&
		    ip_set_timeout_expired(ext_timeout(x, set))) {
			set->elements--;
			ret = 0;
		} else if (!(flags & IPSET_FLAG_EXIST)) {
			set_bit(e->id, map->members);
			return -IPSET_ERR_EXIST;
		}
		/* Element is re-added, cleanup extensions */
		ip_set_ext_destroy(set, x);
	}
	if (ret > 0)
		set->elements--;

	if (SET_WITH_TIMEOUT(set))
#ifdef IP_SET_BITMAP_STORED_TIMEOUT
		mtype_add_timeout(ext_timeout(x, set), e, ext, set, map, ret);
#else
		ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
#endif

	if (SET_WITH_COUNTER(set))
		ip_set_init_counter(ext_counter(x, set), ext);
	if (SET_WITH_COMMENT(set))
		ip_set_init_comment(set, ext_comment(x, set), ext);
	if (SET_WITH_SKBINFO(set))
		ip_set_init_skbinfo(ext_skbinfo(x, set), ext);

	/* Activate element */
	set_bit(e->id, map->members);
	set->elements++;

	return 0;
}

static int
mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
	  struct ip_set_ext *mext, u32 flags)
{
	struct mtype *map = set->data;
	const struct mtype_adt_elem *e = value;
	void *x = get_ext(set, map, e->id);

	if (mtype_do_del(e, map))
		return -IPSET_ERR_EXIST;

	ip_set_ext_destroy(set, x);
	set->elements--;
	if (SET_WITH_TIMEOUT(set) &&
	    ip_set_timeout_expired(ext_timeout(x, set)))
		return -IPSET_ERR_EXIST;

	return 0;
}

#ifndef IP_SET_BITMAP_STORED_TIMEOUT
static bool
mtype_is_filled(const struct mtype_elem *x)
{
	return true;
}
#endif

static int
mtype_list(const struct ip_set *set,
	   struct sk_buff *skb, struct netlink_callback *cb)
{
	struct mtype *map = set->data;
	struct nlattr *adt, *nested;
	void *x;
	u32 id, first = cb->args[IPSET_CB_ARG0];
	int ret = 0;

	adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
	if (!adt)
		return -EMSGSIZE;
	/* Extensions may be replaced */
	rcu_read_lock();
	for (; cb->args[IPSET_CB_ARG0] < map->elements;
	     cb->args[IPSET_CB_ARG0]++) {
		cond_resched_rcu();
		id = cb->args[IPSET_CB_ARG0];
		x = get_ext(set, map, id);
		if (!test_bit(id, map->members) ||
		    (SET_WITH_TIMEOUT(set) &&
#ifdef IP_SET_BITMAP_STORED_TIMEOUT
		     mtype_is_filled(x) &&
#endif
		     ip_set_timeout_expired(ext_timeout(x, set))))
			continue;
		nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
		if (!nested) {
			if (id == first) {
				nla_nest_cancel(skb, adt);
				ret = -EMSGSIZE;
				goto out;
			}

			goto nla_put_failure;
		}
		if (mtype_do_list(skb, map, id, set->dsize))
			goto nla_put_failure;
		if (ip_set_put_extensions(skb, set, x, mtype_is_filled(x)))
			goto nla_put_failure;
		ipset_nest_end(skb, nested);
	}
	ipset_nest_end(skb, adt);

	/* Set listing finished */
	cb->args[IPSET_CB_ARG0] = 0;

	goto out;

nla_put_failure:
	nla_nest_cancel(skb, nested);
	if (unlikely(id == first)) {
		cb->args[IPSET_CB_ARG0] = 0;
		ret = -EMSGSIZE;
	}
	ipset_nest_end(skb, adt);
out:
	rcu_read_unlock();
	return ret;
}

static void
mtype_gc(GC_ARG)
{
	INIT_GC_VARS(mtype, map);
	void *x;
	u32 id;

	/* We run parallel with other readers (test element)
	 * but adding/deleting new entries is locked out
	 */
	spin_lock_bh(&set->lock);
	for (id = 0; id < map->elements; id++)
		if (mtype_gc_test(id, map, set->dsize)) {
			x = get_ext(set, map, id);
			if (ip_set_timeout_expired(ext_timeout(x, set))) {
				clear_bit(id, map->members);
				ip_set_ext_destroy(set, x);
				set->elements--;
			}
		}
	spin_unlock_bh(&set->lock);

	map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
	add_timer(&map->gc);
}

static void
mtype_cancel_gc(struct ip_set *set)
{
	struct mtype *map = set->data;

	if (SET_WITH_TIMEOUT(set))
		del_timer_sync(&map->gc);
}

static const struct ip_set_type_variant mtype = {
	.kadt	= mtype_kadt,
	.uadt	= mtype_uadt,
	.adt	= {
		[IPSET_ADD] = mtype_add,
		[IPSET_DEL] = mtype_del,
		[IPSET_TEST] = mtype_test,
	},
	.destroy = mtype_destroy,
	.flush	= mtype_flush,
	.head	= mtype_head,
	.list	= mtype_list,
	.same_set = mtype_same_set,
	.cancel_gc = mtype_cancel_gc,
};

#endif /* __IP_SET_BITMAP_IP_GEN_H */
Commit	Line	Data
6cd9def1	1	/* SPDX-License-Identifier: GPL-2.0-only */
0fdebb3b	2	/* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@netfilter.org>
e2f4b810 JK	3	*/
	4
	5	#ifndef __IP_SET_BITMAP_IP_GEN_H
	6	#define __IP_SET_BITMAP_IP_GEN_H
	7
76e1fadb JK	8	#define mtype_do_test IPSET_TOKEN(MTYPE, _do_test)
	9	#define mtype_gc_test IPSET_TOKEN(MTYPE, _gc_test)
	10	#define mtype_is_filled IPSET_TOKEN(MTYPE, _is_filled)
	11	#define mtype_do_add IPSET_TOKEN(MTYPE, _do_add)
92f6f53b	12	#define mtype_ext_cleanup IPSET_TOKEN(MTYPE, _ext_cleanup)
76e1fadb JK	13	#define mtype_do_del IPSET_TOKEN(MTYPE, _do_del)
	14	#define mtype_do_list IPSET_TOKEN(MTYPE, _do_list)
	15	#define mtype_do_head IPSET_TOKEN(MTYPE, _do_head)
	16	#define mtype_adt_elem IPSET_TOKEN(MTYPE, _adt_elem)
	17	#define mtype_add_timeout IPSET_TOKEN(MTYPE, _add_timeout)
	18	#define mtype_gc_init IPSET_TOKEN(MTYPE, _gc_init)
	19	#define mtype_kadt IPSET_TOKEN(MTYPE, _kadt)
	20	#define mtype_uadt IPSET_TOKEN(MTYPE, _uadt)
	21	#define mtype_destroy IPSET_TOKEN(MTYPE, _destroy)
d897885a	22	#define mtype_memsize IPSET_TOKEN(MTYPE, _memsize)
76e1fadb JK	23	#define mtype_flush IPSET_TOKEN(MTYPE, _flush)
	24	#define mtype_head IPSET_TOKEN(MTYPE, _head)
	25	#define mtype_same_set IPSET_TOKEN(MTYPE, _same_set)
	26	#define mtype_elem IPSET_TOKEN(MTYPE, _elem)
	27	#define mtype_test IPSET_TOKEN(MTYPE, _test)
	28	#define mtype_add IPSET_TOKEN(MTYPE, _add)
	29	#define mtype_del IPSET_TOKEN(MTYPE, _del)
	30	#define mtype_list IPSET_TOKEN(MTYPE, _list)
	31	#define mtype_gc IPSET_TOKEN(MTYPE, _gc)
148fad4d	32	#define mtype_cancel_gc IPSET_TOKEN(MTYPE, _cancel_gc)
e2f4b810 JK	33	#define mtype MTYPE
e2f4b810 JK	34
c7cf6f3b	35	#define get_ext(set, map, id) ((map)->extensions + ((set)->dsize * (id)))
e2f4b810 JK	36
e2f4b810 JK	37	static void
0a81ab50	38	mtype_gc_init(struct ip_set set, void (gc)(GC_ARG))
e2f4b810 JK	39	{
	40	struct mtype *map = set->data;
	41
0a81ab50	42	TIMER_SETUP(&map->gc, gc);
8f6237f6	43	mod_timer(&map->gc, jiffies + IPSET_GC_PERIOD(set->timeout) * HZ);
e2f4b810 JK	44	}
e2f4b810 JK	45
92f6f53b JK	46	static void
	47	mtype_ext_cleanup(struct ip_set *set)
	48	{
	49	struct mtype *map = set->data;
	50	u32 id;
	51
	52	for (id = 0; id < map->elements; id++)
	53	if (test_bit(id, map->members))
	54	ip_set_ext_destroy(set, get_ext(set, map, id));
	55	}
	56
e2f4b810 JK	57	static void
	58	mtype_destroy(struct ip_set *set)
	59	{
	60	struct mtype *map = set->data;
	61
c7cf6f3b JK	62	if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
c7cf6f3b JK	63	mtype_ext_cleanup(set);
d5bfa437	64	ip_set_free(map->members);
c7cf6f3b	65	ip_set_free(map);
e2f4b810 JK	66
	67	set->data = NULL;
	68	}
	69
	70	static void
	71	mtype_flush(struct ip_set *set)
	72	{
	73	struct mtype *map = set->data;
	74
92f6f53b JK	75	if (set->extensions & IPSET_EXT_DESTROY)
92f6f53b JK	76	mtype_ext_cleanup(set);
b661f385	77	bitmap_zero(map->members, map->elements);
0c7e18ed	78	set->elements = 0;
5a568889	79	set->ext_size = 0;
e2f4b810 JK	80	}
e2f4b810 JK	81
d897885a JK	82	/* Calculate the actual memory size of the set data */
d897885a JK	83	static size_t
b8251a4a	84	mtype_memsize(const struct mtype *map, size_t dsize)
d897885a	85	{
b8251a4a JK	86	size_t memsize = sizeof(*map) +
	87	map->memsize +
	88	map->elements * dsize;
	89	return memsize;
d897885a JK	90	}
d897885a JK	91
e2f4b810 JK	92	static int
	93	mtype_head(struct ip_set set, struct sk_buff skb)
	94	{
	95	const struct mtype *map = set->data;
	96	struct nlattr *nested;
b8251a4a	97	size_t memsize = mtype_memsize(map, set->dsize) + set->ext_size;
e2f4b810 JK	98
	99	nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
	100	if (!nested)
	101	goto nla_put_failure;
	102	if (mtype_do_head(skb, map) \|\|
4c70c227	103	nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref)) \|\|
0c7e18ed JK	104	nla_put_net32(skb, IPSET_ATTR_MEMSIZE, htonl(memsize)) \|\|
0c7e18ed JK	105	nla_put_net32(skb, IPSET_ATTR_ELEMENTS, htonl(set->elements)))
9af0e20d OS	106	goto nla_put_failure;
9af0e20d OS	107	if (unlikely(ip_set_put_flags(skb, set)))
e2f4b810 JK	108	goto nla_put_failure;
	109	ipset_nest_end(skb, nested);
	110
	111	return 0;
	112	nla_put_failure:
	113	return -EMSGSIZE;
	114	}
	115
	116	static int
	117	mtype_test(struct ip_set set, void value, const struct ip_set_ext *ext,
	118	struct ip_set_ext *mext, u32 flags)
	119	{
	120	struct mtype *map = set->data;
	121	const struct mtype_adt_elem *e = value;
71b092cb JK	122	void *x = get_ext(set, map, e->id);
71b092cb JK	123	int ret = mtype_do_test(e, map, set->dsize);
e2f4b810 JK	124
	125	if (ret <= 0)
	126	return ret;
ad92ed77	127	return ip_set_match_extensions(set, ext, mext, flags, x);
e2f4b810 JK	128	}
	129
	130	static int
	131	mtype_add(struct ip_set set, void value, const struct ip_set_ext *ext,
	132	struct ip_set_ext *mext, u32 flags)
	133	{
	134	struct mtype *map = set->data;
	135	const struct mtype_adt_elem *e = value;
71b092cb JK	136	void *x = get_ext(set, map, e->id);
71b092cb JK	137	int ret = mtype_do_add(e, map, flags, set->dsize);
e2f4b810 JK	138
	139	if (ret == IPSET_ADD_FAILED) {
	140	if (SET_WITH_TIMEOUT(set) &&
e91b76ec	141	ip_set_timeout_expired(ext_timeout(x, set))) {
0c7e18ed	142	set->elements--;
e2f4b810	143	ret = 0;
e91b76ec JK	144	} else if (!(flags & IPSET_FLAG_EXIST)) {
e91b76ec JK	145	set_bit(e->id, map->members);
e2f4b810	146	return -IPSET_ERR_EXIST;
e91b76ec	147	}
92f6f53b JK	148	/* Element is re-added, cleanup extensions */
92f6f53b JK	149	ip_set_ext_destroy(set, x);
e2f4b810	150	}
0c7e18ed JK	151	if (ret > 0)
0c7e18ed JK	152	set->elements--;
e2f4b810 JK	153
	154	if (SET_WITH_TIMEOUT(set))
	155	#ifdef IP_SET_BITMAP_STORED_TIMEOUT
71b092cb	156	mtype_add_timeout(ext_timeout(x, set), e, ext, set, map, ret);
e2f4b810	157	#else
71b092cb	158	ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
e2f4b810 JK	159	#endif
e2f4b810 JK	160
9272b57d	161	if (SET_WITH_COUNTER(set))
71b092cb	162	ip_set_init_counter(ext_counter(x, set), ext);
9af0e20d	163	if (SET_WITH_COMMENT(set))
5a568889	164	ip_set_init_comment(set, ext_comment(x, set), ext);
b9653a47 AD	165	if (SET_WITH_SKBINFO(set))
b9653a47 AD	166	ip_set_init_skbinfo(ext_skbinfo(x, set), ext);
e91b76ec JK	167
	168	/* Activate element */
	169	set_bit(e->id, map->members);
0c7e18ed	170	set->elements++;
e91b76ec	171
e2f4b810 JK	172	return 0;
	173	}
	174
	175	static int
	176	mtype_del(struct ip_set set, void value, const struct ip_set_ext *ext,
	177	struct ip_set_ext *mext, u32 flags)
	178	{
	179	struct mtype *map = set->data;
	180	const struct mtype_adt_elem *e = value;
92f6f53b	181	void *x = get_ext(set, map, e->id);
e2f4b810	182
92f6f53b JK	183	if (mtype_do_del(e, map))
	184	return -IPSET_ERR_EXIST;
	185
	186	ip_set_ext_destroy(set, x);
0c7e18ed	187	set->elements--;
92f6f53b JK	188	if (SET_WITH_TIMEOUT(set) &&
92f6f53b JK	189	ip_set_timeout_expired(ext_timeout(x, set)))
e2f4b810 JK	190	return -IPSET_ERR_EXIST;
	191
	192	return 0;
	193	}
	194
def57acb	195	#ifndef IP_SET_BITMAP_STORED_TIMEOUT
4392230c	196	static bool
def57acb JK	197	mtype_is_filled(const struct mtype_elem *x)
	198	{
	199	return true;
	200	}
	201	#endif
	202
e2f4b810 JK	203	static int
	204	mtype_list(const struct ip_set *set,
	205	struct sk_buff skb, struct netlink_callback cb)
	206	{
	207	struct mtype *map = set->data;
	208	struct nlattr adt, nested;
	209	void *x;
a61d7ebe	210	u32 id, first = cb->args[IPSET_CB_ARG0];
aa458c2d	211	int ret = 0;
e2f4b810 JK	212
	213	adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
	214	if (!adt)
	215	return -EMSGSIZE;
aa458c2d JK	216	/* Extensions may be replaced */
aa458c2d JK	217	rcu_read_lock();
a61d7ebe JK	218	for (; cb->args[IPSET_CB_ARG0] < map->elements;
a61d7ebe JK	219	cb->args[IPSET_CB_ARG0]++) {
56004fb7	220	cond_resched_rcu();
a61d7ebe	221	id = cb->args[IPSET_CB_ARG0];
71b092cb	222	x = get_ext(set, map, id);
e2f4b810 JK	223	if (!test_bit(id, map->members) \|\|
	224	(SET_WITH_TIMEOUT(set) &&
	225	#ifdef IP_SET_BITMAP_STORED_TIMEOUT
c4c74ae6	226	mtype_is_filled(x) &&
e2f4b810	227	#endif
68ade830	228	ip_set_timeout_expired(ext_timeout(x, set))))
e2f4b810 JK	229	continue;
	230	nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
	231	if (!nested) {
	232	if (id == first) {
	233	nla_nest_cancel(skb, adt);
aa458c2d JK	234	ret = -EMSGSIZE;
aa458c2d JK	235	goto out;
9f497f7e JK	236	}
	237
	238	goto nla_put_failure;
e2f4b810	239	}
71b092cb	240	if (mtype_do_list(skb, map, id, set->dsize))
e2f4b810	241	goto nla_put_failure;
cb410bbb	242	if (ip_set_put_extensions(skb, set, x, mtype_is_filled(x)))
9af0e20d	243	goto nla_put_failure;
e2f4b810 JK	244	ipset_nest_end(skb, nested);
	245	}
	246	ipset_nest_end(skb, adt);
	247
	248	/* Set listing finished */
a61d7ebe	249	cb->args[IPSET_CB_ARG0] = 0;
e2f4b810	250
aa458c2d	251	goto out;
e2f4b810 JK	252
	253	nla_put_failure:
	254	nla_nest_cancel(skb, nested);
e2f4b810	255	if (unlikely(id == first)) {
a61d7ebe	256	cb->args[IPSET_CB_ARG0] = 0;
aa458c2d	257	ret = -EMSGSIZE;
e2f4b810	258	}
5ebed3ba	259	ipset_nest_end(skb, adt);
aa458c2d JK	260	out:
	261	rcu_read_unlock();
	262	return ret;
e2f4b810 JK	263	}
	264
	265	static void
0a81ab50	266	mtype_gc(GC_ARG)
e2f4b810	267	{
0a81ab50	268	INIT_GC_VARS(mtype, map);
92f6f53b	269	void *x;
e2f4b810 JK	270	u32 id;
	271
	272	/* We run parallel with other readers (test element)
9f497f7e JK	273	* but adding/deleting new entries is locked out
9f497f7e JK	274	*/
920ddfa0	275	spin_lock_bh(&set->lock);
e2f4b810	276	for (id = 0; id < map->elements; id++)
71b092cb JK	277	if (mtype_gc_test(id, map, set->dsize)) {
71b092cb JK	278	x = get_ext(set, map, id);
92f6f53b	279	if (ip_set_timeout_expired(ext_timeout(x, set))) {
e2f4b810	280	clear_bit(id, map->members);
92f6f53b	281	ip_set_ext_destroy(set, x);
0c7e18ed	282	set->elements--;
92f6f53b	283	}
e2f4b810	284	}
920ddfa0	285	spin_unlock_bh(&set->lock);
e2f4b810	286
71b092cb	287	map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
e2f4b810 JK	288	add_timer(&map->gc);
	289	}
	290
148fad4d JK	291	static void
	292	mtype_cancel_gc(struct ip_set *set)
	293	{
	294	struct mtype *map = set->data;
	295
	296	if (SET_WITH_TIMEOUT(set))
	297	del_timer_sync(&map->gc);
	298	}
	299
e2f4b810 JK	300	static const struct ip_set_type_variant mtype = {
	301	.kadt = mtype_kadt,
	302	.uadt = mtype_uadt,
	303	.adt = {
	304	[IPSET_ADD] = mtype_add,
	305	[IPSET_DEL] = mtype_del,
	306	[IPSET_TEST] = mtype_test,
	307	},
	308	.destroy = mtype_destroy,
	309	.flush = mtype_flush,
	310	.head = mtype_head,
	311	.list = mtype_list,
	312	.same_set = mtype_same_set,
148fad4d	313	.cancel_gc = mtype_cancel_gc,
e2f4b810 JK	314	};
	315
	316	#endif /* __IP_SET_BITMAP_IP_GEN_H */