1 /* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@blackhole.kfki.hu>
2 *
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.
6 */
7
8 #ifndef __IP_SET_BITMAP_IP_GEN_H
9 #define __IP_SET_BITMAP_IP_GEN_H
10
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)
35 #define mtype MTYPE
36
37 #define get_ext(set, map, id) ((map)->extensions + ((set)->dsize * (id)))
38
39 static void
mtype_gc_init(struct ip_set * set,void (* gc)(struct timer_list * t))40 mtype_gc_init(struct ip_set *set, void (*gc)(struct timer_list *t))
41 {
42 struct mtype *map = set->data;
43
44 timer_setup(&map->gc, gc, 0);
45 mod_timer(&map->gc, jiffies + IPSET_GC_PERIOD(set->timeout) * HZ);
46 }
47
48 static void
mtype_ext_cleanup(struct ip_set * set)49 mtype_ext_cleanup(struct ip_set *set)
50 {
51 struct mtype *map = set->data;
52 u32 id;
53
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));
57 }
58
59 static void
mtype_destroy(struct ip_set * set)60 mtype_destroy(struct ip_set *set)
61 {
62 struct mtype *map = set->data;
63
64 if (SET_WITH_TIMEOUT(set))
65 del_timer_sync(&map->gc);
66
67 ip_set_free(map->members);
68 if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
69 mtype_ext_cleanup(set);
70 ip_set_free(map);
71
72 set->data = NULL;
73 }
74
75 static void
mtype_flush(struct ip_set * set)76 mtype_flush(struct ip_set *set)
77 {
78 struct mtype *map = set->data;
79
80 if (set->extensions & IPSET_EXT_DESTROY)
81 mtype_ext_cleanup(set);
82 memset(map->members, 0, map->memsize);
83 set->elements = 0;
84 set->ext_size = 0;
85 }
86
87 /* Calculate the actual memory size of the set data */
88 static size_t
mtype_memsize(const struct mtype * map,size_t dsize)89 mtype_memsize(const struct mtype *map, size_t dsize)
90 {
91 return sizeof(*map) + map->memsize +
92 map->elements * dsize;
93 }
94
95 static int
mtype_head(struct ip_set * set,struct sk_buff * skb)96 mtype_head(struct ip_set *set, struct sk_buff *skb)
97 {
98 const struct mtype *map = set->data;
99 struct nlattr *nested;
100 size_t memsize = mtype_memsize(map, set->dsize) + set->ext_size;
101
102 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
103 if (!nested)
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);
113
114 return 0;
115 nla_put_failure:
116 return -EMSGSIZE;
117 }
118
119 static int
mtype_test(struct ip_set * set,void * value,const struct ip_set_ext * ext,struct ip_set_ext * mext,u32 flags)120 mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
121 struct ip_set_ext *mext, u32 flags)
122 {
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);
127
128 if (ret <= 0)
129 return ret;
130 return ip_set_match_extensions(set, ext, mext, flags, x);
131 }
132
133 static int
mtype_add(struct ip_set * set,void * value,const struct ip_set_ext * ext,struct ip_set_ext * mext,u32 flags)134 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
135 struct ip_set_ext *mext, u32 flags)
136 {
137 struct mtype *map = set->data;
138 const struct mtype_adt_elem *e = value;
139 void *x = get_ext(set, map, e->id);
140 int ret = mtype_do_add(e, map, flags, set->dsize);
141
142 if (ret == IPSET_ADD_FAILED) {
143 if (SET_WITH_TIMEOUT(set) &&
144 ip_set_timeout_expired(ext_timeout(x, set))) {
145 set->elements--;
146 ret = 0;
147 } else if (!(flags & IPSET_FLAG_EXIST)) {
148 set_bit(e->id, map->members);
149 return -IPSET_ERR_EXIST;
150 }
151 /* Element is re-added, cleanup extensions */
152 ip_set_ext_destroy(set, x);
153 }
154 if (ret > 0)
155 set->elements--;
156
157 if (SET_WITH_TIMEOUT(set))
158 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
159 mtype_add_timeout(ext_timeout(x, set), e, ext, set, map, ret);
160 #else
161 ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
162 #endif
163
164 if (SET_WITH_COUNTER(set))
165 ip_set_init_counter(ext_counter(x, set), ext);
166 if (SET_WITH_COMMENT(set))
167 ip_set_init_comment(set, ext_comment(x, set), ext);
168 if (SET_WITH_SKBINFO(set))
169 ip_set_init_skbinfo(ext_skbinfo(x, set), ext);
170
171 /* Activate element */
172 set_bit(e->id, map->members);
173 set->elements++;
174
175 return 0;
176 }
177
178 static int
mtype_del(struct ip_set * set,void * value,const struct ip_set_ext * ext,struct ip_set_ext * mext,u32 flags)179 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
180 struct ip_set_ext *mext, u32 flags)
181 {
182 struct mtype *map = set->data;
183 const struct mtype_adt_elem *e = value;
184 void *x = get_ext(set, map, e->id);
185
186 if (mtype_do_del(e, map))
187 return -IPSET_ERR_EXIST;
188
189 ip_set_ext_destroy(set, x);
190 set->elements--;
191 if (SET_WITH_TIMEOUT(set) &&
192 ip_set_timeout_expired(ext_timeout(x, set)))
193 return -IPSET_ERR_EXIST;
194
195 return 0;
196 }
197
198 #ifndef IP_SET_BITMAP_STORED_TIMEOUT
199 static inline bool
mtype_is_filled(const struct mtype_elem * x)200 mtype_is_filled(const struct mtype_elem *x)
201 {
202 return true;
203 }
204 #endif
205
206 static int
mtype_list(const struct ip_set * set,struct sk_buff * skb,struct netlink_callback * cb)207 mtype_list(const struct ip_set *set,
208 struct sk_buff *skb, struct netlink_callback *cb)
209 {
210 struct mtype *map = set->data;
211 struct nlattr *adt, *nested;
212 void *x;
213 u32 id, first = cb->args[IPSET_CB_ARG0];
214 int ret = 0;
215
216 adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
217 if (!adt)
218 return -EMSGSIZE;
219 /* Extensions may be replaced */
220 rcu_read_lock();
221 for (; cb->args[IPSET_CB_ARG0] < map->elements;
222 cb->args[IPSET_CB_ARG0]++) {
223 cond_resched_rcu();
224 id = cb->args[IPSET_CB_ARG0];
225 x = get_ext(set, map, id);
226 if (!test_bit(id, map->members) ||
227 (SET_WITH_TIMEOUT(set) &&
228 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
229 mtype_is_filled(x) &&
230 #endif
231 ip_set_timeout_expired(ext_timeout(x, set))))
232 continue;
233 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
234 if (!nested) {
235 if (id == first) {
236 nla_nest_cancel(skb, adt);
237 ret = -EMSGSIZE;
238 goto out;
239 }
240
241 goto nla_put_failure;
242 }
243 if (mtype_do_list(skb, map, id, set->dsize))
244 goto nla_put_failure;
245 if (ip_set_put_extensions(skb, set, x, mtype_is_filled(x)))
246 goto nla_put_failure;
247 ipset_nest_end(skb, nested);
248 }
249 ipset_nest_end(skb, adt);
250
251 /* Set listing finished */
252 cb->args[IPSET_CB_ARG0] = 0;
253
254 goto out;
255
256 nla_put_failure:
257 nla_nest_cancel(skb, nested);
258 if (unlikely(id == first)) {
259 cb->args[IPSET_CB_ARG0] = 0;
260 ret = -EMSGSIZE;
261 }
262 ipset_nest_end(skb, adt);
263 out:
264 rcu_read_unlock();
265 return ret;
266 }
267
268 static void
mtype_gc(struct timer_list * t)269 mtype_gc(struct timer_list *t)
270 {
271 struct mtype *map = from_timer(map, t, gc);
272 struct ip_set *set = map->set;
273 void *x;
274 u32 id;
275
276 /* We run parallel with other readers (test element)
277 * but adding/deleting new entries is locked out
278 */
279 spin_lock_bh(&set->lock);
280 for (id = 0; id < map->elements; id++)
281 if (mtype_gc_test(id, map, set->dsize)) {
282 x = get_ext(set, map, id);
283 if (ip_set_timeout_expired(ext_timeout(x, set))) {
284 clear_bit(id, map->members);
285 ip_set_ext_destroy(set, x);
286 set->elements--;
287 }
288 }
289 spin_unlock_bh(&set->lock);
290
291 map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
292 add_timer(&map->gc);
293 }
294
295 static const struct ip_set_type_variant mtype = {
296 .kadt = mtype_kadt,
297 .uadt = mtype_uadt,
298 .adt = {
299 [IPSET_ADD] = mtype_add,
300 [IPSET_DEL] = mtype_del,
301 [IPSET_TEST] = mtype_test,
302 },
303 .destroy = mtype_destroy,
304 .flush = mtype_flush,
305 .head = mtype_head,
306 .list = mtype_list,
307 .same_set = mtype_same_set,
308 };
309
310 #endif /* __IP_SET_BITMAP_IP_GEN_H */
311
