1 /* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
8 #ifndef __IP_SET_BITMAP_IP_GEN_H
9 #define __IP_SET_BITMAP_IP_GEN_H
11 #define mtype_do_test IPSET_TOKEN(MTYPE, _do_test)
12 #define mtype_gc_test IPSET_TOKEN(MTYPE, _gc_test)
13 #define mtype_is_filled IPSET_TOKEN(MTYPE, _is_filled)
14 #define mtype_do_add IPSET_TOKEN(MTYPE, _do_add)
15 #define mtype_ext_cleanup IPSET_TOKEN(MTYPE, _ext_cleanup)
16 #define mtype_do_del IPSET_TOKEN(MTYPE, _do_del)
17 #define mtype_do_list IPSET_TOKEN(MTYPE, _do_list)
18 #define mtype_do_head IPSET_TOKEN(MTYPE, _do_head)
19 #define mtype_adt_elem IPSET_TOKEN(MTYPE, _adt_elem)
20 #define mtype_add_timeout IPSET_TOKEN(MTYPE, _add_timeout)
21 #define mtype_gc_init IPSET_TOKEN(MTYPE, _gc_init)
22 #define mtype_kadt IPSET_TOKEN(MTYPE, _kadt)
23 #define mtype_uadt IPSET_TOKEN(MTYPE, _uadt)
24 #define mtype_destroy IPSET_TOKEN(MTYPE, _destroy)
25 #define mtype_memsize IPSET_TOKEN(MTYPE, _memsize)
26 #define mtype_flush IPSET_TOKEN(MTYPE, _flush)
27 #define mtype_head IPSET_TOKEN(MTYPE, _head)
28 #define mtype_same_set IPSET_TOKEN(MTYPE, _same_set)
29 #define mtype_elem IPSET_TOKEN(MTYPE, _elem)
30 #define mtype_test IPSET_TOKEN(MTYPE, _test)
31 #define mtype_add IPSET_TOKEN(MTYPE, _add)
32 #define mtype_del IPSET_TOKEN(MTYPE, _del)
33 #define mtype_list IPSET_TOKEN(MTYPE, _list)
34 #define mtype_gc IPSET_TOKEN(MTYPE, _gc)
37 #define get_ext(set, map, id) ((map)->extensions + ((set)->dsize * (id)))
40 mtype_gc_init(struct ip_set
*set
, void (*gc
)(struct timer_list
*t
))
42 struct mtype
*map
= set
->data
;
44 timer_setup(&map
->gc
, gc
, 0);
45 mod_timer(&map
->gc
, jiffies
+ IPSET_GC_PERIOD(set
->timeout
) * HZ
);
49 mtype_ext_cleanup(struct ip_set
*set
)
51 struct mtype
*map
= set
->data
;
54 for (id
= 0; id
< map
->elements
; id
++)
55 if (test_bit(id
, map
->members
))
56 ip_set_ext_destroy(set
, get_ext(set
, map
, id
));
60 mtype_destroy(struct ip_set
*set
)
62 struct mtype
*map
= set
->data
;
64 if (SET_WITH_TIMEOUT(set
))
65 del_timer_sync(&map
->gc
);
67 ip_set_free(map
->members
);
68 if (set
->dsize
&& set
->extensions
& IPSET_EXT_DESTROY
)
69 mtype_ext_cleanup(set
);
76 mtype_flush(struct ip_set
*set
)
78 struct mtype
*map
= set
->data
;
80 if (set
->extensions
& IPSET_EXT_DESTROY
)
81 mtype_ext_cleanup(set
);
82 memset(map
->members
, 0, map
->memsize
);
87 /* Calculate the actual memory size of the set data */
89 mtype_memsize(const struct mtype
*map
, size_t dsize
)
91 return sizeof(*map
) + map
->memsize
+
92 map
->elements
* dsize
;
96 mtype_head(struct ip_set
*set
, struct sk_buff
*skb
)
98 const struct mtype
*map
= set
->data
;
99 struct nlattr
*nested
;
100 size_t memsize
= mtype_memsize(map
, set
->dsize
) + set
->ext_size
;
102 nested
= ipset_nest_start(skb
, IPSET_ATTR_DATA
);
104 goto nla_put_failure
;
105 if (mtype_do_head(skb
, map
) ||
106 nla_put_net32(skb
, IPSET_ATTR_REFERENCES
, htonl(set
->ref
)) ||
107 nla_put_net32(skb
, IPSET_ATTR_MEMSIZE
, htonl(memsize
)) ||
108 nla_put_net32(skb
, IPSET_ATTR_ELEMENTS
, htonl(set
->elements
)))
109 goto nla_put_failure
;
110 if (unlikely(ip_set_put_flags(skb
, set
)))
111 goto nla_put_failure
;
112 ipset_nest_end(skb
, nested
);
120 mtype_test(struct ip_set
*set
, void *value
, const struct ip_set_ext
*ext
,
121 struct ip_set_ext
*mext
, u32 flags
)
123 struct mtype
*map
= set
->data
;
124 const struct mtype_adt_elem
*e
= value
;
125 void *x
= get_ext(set
, map
, e
->id
);
126 int ret
= mtype_do_test(e
, map
, set
->dsize
);
130 if (SET_WITH_TIMEOUT(set
) &&
131 ip_set_timeout_expired(ext_timeout(x
, set
)))
133 if (SET_WITH_COUNTER(set
))
134 ip_set_update_counter(ext_counter(x
, set
), ext
, mext
, flags
);
135 if (SET_WITH_SKBINFO(set
))
136 ip_set_get_skbinfo(ext_skbinfo(x
, set
), ext
, mext
, flags
);
141 mtype_add(struct ip_set
*set
, void *value
, const struct ip_set_ext
*ext
,
142 struct ip_set_ext
*mext
, u32 flags
)
144 struct mtype
*map
= set
->data
;
145 const struct mtype_adt_elem
*e
= value
;
146 void *x
= get_ext(set
, map
, e
->id
);
147 int ret
= mtype_do_add(e
, map
, flags
, set
->dsize
);
149 if (ret
== IPSET_ADD_FAILED
) {
150 if (SET_WITH_TIMEOUT(set
) &&
151 ip_set_timeout_expired(ext_timeout(x
, set
))) {
154 } else if (!(flags
& IPSET_FLAG_EXIST
)) {
155 set_bit(e
->id
, map
->members
);
156 return -IPSET_ERR_EXIST
;
158 /* Element is re-added, cleanup extensions */
159 ip_set_ext_destroy(set
, x
);
164 if (SET_WITH_TIMEOUT(set
))
165 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
166 mtype_add_timeout(ext_timeout(x
, set
), e
, ext
, set
, map
, ret
);
168 ip_set_timeout_set(ext_timeout(x
, set
), ext
->timeout
);
171 if (SET_WITH_COUNTER(set
))
172 ip_set_init_counter(ext_counter(x
, set
), ext
);
173 if (SET_WITH_COMMENT(set
))
174 ip_set_init_comment(set
, ext_comment(x
, set
), ext
);
175 if (SET_WITH_SKBINFO(set
))
176 ip_set_init_skbinfo(ext_skbinfo(x
, set
), ext
);
178 /* Activate element */
179 set_bit(e
->id
, map
->members
);
186 mtype_del(struct ip_set
*set
, void *value
, const struct ip_set_ext
*ext
,
187 struct ip_set_ext
*mext
, u32 flags
)
189 struct mtype
*map
= set
->data
;
190 const struct mtype_adt_elem
*e
= value
;
191 void *x
= get_ext(set
, map
, e
->id
);
193 if (mtype_do_del(e
, map
))
194 return -IPSET_ERR_EXIST
;
196 ip_set_ext_destroy(set
, x
);
198 if (SET_WITH_TIMEOUT(set
) &&
199 ip_set_timeout_expired(ext_timeout(x
, set
)))
200 return -IPSET_ERR_EXIST
;
205 #ifndef IP_SET_BITMAP_STORED_TIMEOUT
207 mtype_is_filled(const struct mtype_elem
*x
)
214 mtype_list(const struct ip_set
*set
,
215 struct sk_buff
*skb
, struct netlink_callback
*cb
)
217 struct mtype
*map
= set
->data
;
218 struct nlattr
*adt
, *nested
;
220 u32 id
, first
= cb
->args
[IPSET_CB_ARG0
];
223 adt
= ipset_nest_start(skb
, IPSET_ATTR_ADT
);
226 /* Extensions may be replaced */
228 for (; cb
->args
[IPSET_CB_ARG0
] < map
->elements
;
229 cb
->args
[IPSET_CB_ARG0
]++) {
230 id
= cb
->args
[IPSET_CB_ARG0
];
231 x
= get_ext(set
, map
, id
);
232 if (!test_bit(id
, map
->members
) ||
233 (SET_WITH_TIMEOUT(set
) &&
234 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
235 mtype_is_filled(x
) &&
237 ip_set_timeout_expired(ext_timeout(x
, set
))))
239 nested
= ipset_nest_start(skb
, IPSET_ATTR_DATA
);
242 nla_nest_cancel(skb
, adt
);
247 goto nla_put_failure
;
249 if (mtype_do_list(skb
, map
, id
, set
->dsize
))
250 goto nla_put_failure
;
251 if (ip_set_put_extensions(skb
, set
, x
, mtype_is_filled(x
)))
252 goto nla_put_failure
;
253 ipset_nest_end(skb
, nested
);
255 ipset_nest_end(skb
, adt
);
257 /* Set listing finished */
258 cb
->args
[IPSET_CB_ARG0
] = 0;
263 nla_nest_cancel(skb
, nested
);
264 if (unlikely(id
== first
)) {
265 cb
->args
[IPSET_CB_ARG0
] = 0;
268 ipset_nest_end(skb
, adt
);
275 mtype_gc(struct timer_list
*t
)
277 struct mtype
*map
= from_timer(map
, t
, gc
);
278 struct ip_set
*set
= map
->set
;
282 /* We run parallel with other readers (test element)
283 * but adding/deleting new entries is locked out
285 spin_lock_bh(&set
->lock
);
286 for (id
= 0; id
< map
->elements
; id
++)
287 if (mtype_gc_test(id
, map
, set
->dsize
)) {
288 x
= get_ext(set
, map
, id
);
289 if (ip_set_timeout_expired(ext_timeout(x
, set
))) {
290 clear_bit(id
, map
->members
);
291 ip_set_ext_destroy(set
, x
);
295 spin_unlock_bh(&set
->lock
);
297 map
->gc
.expires
= jiffies
+ IPSET_GC_PERIOD(set
->timeout
) * HZ
;
301 static const struct ip_set_type_variant mtype
= {
305 [IPSET_ADD
] = mtype_add
,
306 [IPSET_DEL
] = mtype_del
,
307 [IPSET_TEST
] = mtype_test
,
309 .destroy
= mtype_destroy
,
310 .flush
= mtype_flush
,
313 .same_set
= mtype_same_set
,
316 #endif /* __IP_SET_BITMAP_IP_GEN_H */