~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/netfilter/ipset/ip_set_hash_gen.h

Version: ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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_HASH_GEN_H
  9 #define _IP_SET_HASH_GEN_H
 10 
 11 #include <linux/rcupdate.h>
 12 #include <linux/jhash.h>
 13 #include <linux/netfilter/ipset/ip_set_timeout.h>
 14 #ifndef rcu_dereference_bh
 15 #define rcu_dereference_bh(p)   rcu_dereference(p)
 16 #endif
 17 
 18 #define CONCAT(a, b)            a##b
 19 #define TOKEN(a, b)             CONCAT(a, b)
 20 
 21 /* Hashing which uses arrays to resolve clashing. The hash table is resized
 22  * (doubled) when searching becomes too long.
 23  * Internally jhash is used with the assumption that the size of the
 24  * stored data is a multiple of sizeof(u32). If storage supports timeout,
 25  * the timeout field must be the last one in the data structure - that field
 26  * is ignored when computing the hash key.
 27  *
 28  * Readers and resizing
 29  *
 30  * Resizing can be triggered by userspace command only, and those
 31  * are serialized by the nfnl mutex. During resizing the set is
 32  * read-locked, so the only possible concurrent operations are
 33  * the kernel side readers. Those must be protected by proper RCU locking.
 34  */
 35 
 36 /* Number of elements to store in an initial array block */
 37 #define AHASH_INIT_SIZE                 4
 38 /* Max number of elements to store in an array block */
 39 #define AHASH_MAX_SIZE                  (3*AHASH_INIT_SIZE)
 40 
 41 /* Max number of elements can be tuned */
 42 #ifdef IP_SET_HASH_WITH_MULTI
 43 #define AHASH_MAX(h)                    ((h)->ahash_max)
 44 
 45 static inline u8
 46 tune_ahash_max(u8 curr, u32 multi)
 47 {
 48         u32 n;
 49 
 50         if (multi < curr)
 51                 return curr;
 52 
 53         n = curr + AHASH_INIT_SIZE;
 54         /* Currently, at listing one hash bucket must fit into a message.
 55          * Therefore we have a hard limit here.
 56          */
 57         return n > curr && n <= 64 ? n : curr;
 58 }
 59 #define TUNE_AHASH_MAX(h, multi)        \
 60         ((h)->ahash_max = tune_ahash_max((h)->ahash_max, multi))
 61 #else
 62 #define AHASH_MAX(h)                    AHASH_MAX_SIZE
 63 #define TUNE_AHASH_MAX(h, multi)
 64 #endif
 65 
 66 /* A hash bucket */
 67 struct hbucket {
 68         void *value;            /* the array of the values */
 69         u8 size;                /* size of the array */
 70         u8 pos;                 /* position of the first free entry */
 71 };
 72 
 73 /* The hash table: the table size stored here in order to make resizing easy */
 74 struct htable {
 75         u8 htable_bits;         /* size of hash table == 2^htable_bits */
 76         struct hbucket bucket[0]; /* hashtable buckets */
 77 };
 78 
 79 #define hbucket(h, i)           (&((h)->bucket[i]))
 80 
 81 /* Book-keeping of the prefixes added to the set */
 82 struct net_prefixes {
 83         u8 cidr;                /* the different cidr values in the set */
 84         u32 nets;               /* number of elements per cidr */
 85 };
 86 
 87 /* Compute the hash table size */
 88 static size_t
 89 htable_size(u8 hbits)
 90 {
 91         size_t hsize;
 92 
 93         /* We must fit both into u32 in jhash and size_t */
 94         if (hbits > 31)
 95                 return 0;
 96         hsize = jhash_size(hbits);
 97         if ((((size_t)-1) - sizeof(struct htable))/sizeof(struct hbucket)
 98             < hsize)
 99                 return 0;
100 
101         return hsize * sizeof(struct hbucket) + sizeof(struct htable);
102 }
103 
104 /* Compute htable_bits from the user input parameter hashsize */
105 static u8
106 htable_bits(u32 hashsize)
107 {
108         /* Assume that hashsize == 2^htable_bits */
109         u8 bits = fls(hashsize - 1);
110         if (jhash_size(bits) != hashsize)
111                 /* Round up to the first 2^n value */
112                 bits = fls(hashsize);
113 
114         return bits;
115 }
116 
117 /* Destroy the hashtable part of the set */
118 static void
119 ahash_destroy(struct htable *t)
120 {
121         struct hbucket *n;
122         u32 i;
123 
124         for (i = 0; i < jhash_size(t->htable_bits); i++) {
125                 n = hbucket(t, i);
126                 if (n->size)
127                         /* FIXME: use slab cache */
128                         kfree(n->value);
129         }
130 
131         ip_set_free(t);
132 }
133 
134 static int
135 hbucket_elem_add(struct hbucket *n, u8 ahash_max, size_t dsize)
136 {
137         if (n->pos >= n->size) {
138                 void *tmp;
139 
140                 if (n->size >= ahash_max)
141                         /* Trigger rehashing */
142                         return -EAGAIN;
143 
144                 tmp = kzalloc((n->size + AHASH_INIT_SIZE) * dsize,
145                               GFP_ATOMIC);
146                 if (!tmp)
147                         return -ENOMEM;
148                 if (n->size) {
149                         memcpy(tmp, n->value, n->size * dsize);
150                         kfree(n->value);
151                 }
152                 n->value = tmp;
153                 n->size += AHASH_INIT_SIZE;
154         }
155         return 0;
156 }
157 
158 #ifdef IP_SET_HASH_WITH_NETS
159 #ifdef IP_SET_HASH_WITH_NETS_PACKED
160 /* When cidr is packed with nomatch, cidr - 1 is stored in the entry */
161 #define CIDR(cidr)              (cidr + 1)
162 #else
163 #define CIDR(cidr)              (cidr)
164 #endif
165 
166 #define SET_HOST_MASK(family)   (family == AF_INET ? 32 : 128)
167 
168 #ifdef IP_SET_HASH_WITH_MULTI
169 #define NETS_LENGTH(family)     (SET_HOST_MASK(family) + 1)
170 #else
171 #define NETS_LENGTH(family)     SET_HOST_MASK(family)
172 #endif
173 
174 #else
175 #define NETS_LENGTH(family)     0
176 #endif /* IP_SET_HASH_WITH_NETS */
177 
178 #define ext_timeout(e, h)       \
179 (unsigned long *)(((void *)(e)) + (h)->offset[IPSET_OFFSET_TIMEOUT])
180 #define ext_counter(e, h)       \
181 (struct ip_set_counter *)(((void *)(e)) + (h)->offset[IPSET_OFFSET_COUNTER])
182 
183 #endif /* _IP_SET_HASH_GEN_H */
184 
185 /* Family dependent templates */
186 
187 #undef ahash_data
188 #undef mtype_data_equal
189 #undef mtype_do_data_match
190 #undef mtype_data_set_flags
191 #undef mtype_data_reset_flags
192 #undef mtype_data_netmask
193 #undef mtype_data_list
194 #undef mtype_data_next
195 #undef mtype_elem
196 
197 #undef mtype_add_cidr
198 #undef mtype_del_cidr
199 #undef mtype_ahash_memsize
200 #undef mtype_flush
201 #undef mtype_destroy
202 #undef mtype_gc_init
203 #undef mtype_same_set
204 #undef mtype_kadt
205 #undef mtype_uadt
206 #undef mtype
207 
208 #undef mtype_add
209 #undef mtype_del
210 #undef mtype_test_cidrs
211 #undef mtype_test
212 #undef mtype_expire
213 #undef mtype_resize
214 #undef mtype_head
215 #undef mtype_list
216 #undef mtype_gc
217 #undef mtype_gc_init
218 #undef mtype_variant
219 #undef mtype_data_match
220 
221 #undef HKEY
222 
223 #define mtype_data_equal        TOKEN(MTYPE, _data_equal)
224 #ifdef IP_SET_HASH_WITH_NETS
225 #define mtype_do_data_match     TOKEN(MTYPE, _do_data_match)
226 #else
227 #define mtype_do_data_match(d)  1
228 #endif
229 #define mtype_data_set_flags    TOKEN(MTYPE, _data_set_flags)
230 #define mtype_data_reset_flags  TOKEN(MTYPE, _data_reset_flags)
231 #define mtype_data_netmask      TOKEN(MTYPE, _data_netmask)
232 #define mtype_data_list         TOKEN(MTYPE, _data_list)
233 #define mtype_data_next         TOKEN(MTYPE, _data_next)
234 #define mtype_elem              TOKEN(MTYPE, _elem)
235 #define mtype_add_cidr          TOKEN(MTYPE, _add_cidr)
236 #define mtype_del_cidr          TOKEN(MTYPE, _del_cidr)
237 #define mtype_ahash_memsize     TOKEN(MTYPE, _ahash_memsize)
238 #define mtype_flush             TOKEN(MTYPE, _flush)
239 #define mtype_destroy           TOKEN(MTYPE, _destroy)
240 #define mtype_gc_init           TOKEN(MTYPE, _gc_init)
241 #define mtype_same_set          TOKEN(MTYPE, _same_set)
242 #define mtype_kadt              TOKEN(MTYPE, _kadt)
243 #define mtype_uadt              TOKEN(MTYPE, _uadt)
244 #define mtype                   MTYPE
245 
246 #define mtype_elem              TOKEN(MTYPE, _elem)
247 #define mtype_add               TOKEN(MTYPE, _add)
248 #define mtype_del               TOKEN(MTYPE, _del)
249 #define mtype_test_cidrs        TOKEN(MTYPE, _test_cidrs)
250 #define mtype_test              TOKEN(MTYPE, _test)
251 #define mtype_expire            TOKEN(MTYPE, _expire)
252 #define mtype_resize            TOKEN(MTYPE, _resize)
253 #define mtype_head              TOKEN(MTYPE, _head)
254 #define mtype_list              TOKEN(MTYPE, _list)
255 #define mtype_gc                TOKEN(MTYPE, _gc)
256 #define mtype_variant           TOKEN(MTYPE, _variant)
257 #define mtype_data_match        TOKEN(MTYPE, _data_match)
258 
259 #ifndef HKEY_DATALEN
260 #define HKEY_DATALEN            sizeof(struct mtype_elem)
261 #endif
262 
263 #define HKEY(data, initval, htable_bits)                        \
264 (jhash2((u32 *)(data), HKEY_DATALEN/sizeof(u32), initval)       \
265         & jhash_mask(htable_bits))
266 
267 #ifndef htype
268 #define htype                   HTYPE
269 
270 /* The generic hash structure */
271 struct htype {
272         struct htable *table;   /* the hash table */
273         u32 maxelem;            /* max elements in the hash */
274         u32 elements;           /* current element (vs timeout) */
275         u32 initval;            /* random jhash init value */
276         u32 timeout;            /* timeout value, if enabled */
277         size_t dsize;           /* data struct size */
278         size_t offset[IPSET_OFFSET_MAX]; /* Offsets to extensions */
279         struct timer_list gc;   /* garbage collection when timeout enabled */
280         struct mtype_elem next; /* temporary storage for uadd */
281 #ifdef IP_SET_HASH_WITH_MULTI
282         u8 ahash_max;           /* max elements in an array block */
283 #endif
284 #ifdef IP_SET_HASH_WITH_NETMASK
285         u8 netmask;             /* netmask value for subnets to store */
286 #endif
287 #ifdef IP_SET_HASH_WITH_RBTREE
288         struct rb_root rbtree;
289 #endif
290 #ifdef IP_SET_HASH_WITH_NETS
291         struct net_prefixes nets[0]; /* book-keeping of prefixes */
292 #endif
293 };
294 #endif
295 
296 #ifdef IP_SET_HASH_WITH_NETS
297 /* Network cidr size book keeping when the hash stores different
298  * sized networks */
299 static void
300 mtype_add_cidr(struct htype *h, u8 cidr, u8 nets_length)
301 {
302         int i, j;
303 
304         /* Add in increasing prefix order, so larger cidr first */
305         for (i = 0, j = -1; i < nets_length && h->nets[i].nets; i++) {
306                 if (j != -1)
307                         continue;
308                 else if (h->nets[i].cidr < cidr)
309                         j = i;
310                 else if (h->nets[i].cidr == cidr) {
311                         h->nets[i].nets++;
312                         return;
313                 }
314         }
315         if (j != -1) {
316                 for (; i > j; i--) {
317                         h->nets[i].cidr = h->nets[i - 1].cidr;
318                         h->nets[i].nets = h->nets[i - 1].nets;
319                 }
320         }
321         h->nets[i].cidr = cidr;
322         h->nets[i].nets = 1;
323 }
324 
325 static void
326 mtype_del_cidr(struct htype *h, u8 cidr, u8 nets_length)
327 {
328         u8 i, j, net_end = nets_length - 1;
329 
330         for (i = 0; i < nets_length; i++) {
331                 if (h->nets[i].cidr != cidr)
332                         continue;
333                 if (h->nets[i].nets > 1 || i == net_end ||
334                     h->nets[i + 1].nets == 0) {
335                         h->nets[i].nets--;
336                         return;
337                 }
338                 for (j = i; j < net_end && h->nets[j].nets; j++) {
339                         h->nets[j].cidr = h->nets[j + 1].cidr;
340                         h->nets[j].nets = h->nets[j + 1].nets;
341                 }
342                 h->nets[j].nets = 0;
343                 return;
344         }
345 }
346 #endif
347 
348 /* Calculate the actual memory size of the set data */
349 static size_t
350 mtype_ahash_memsize(const struct htype *h, u8 nets_length)
351 {
352         u32 i;
353         struct htable *t = h->table;
354         size_t memsize = sizeof(*h)
355                          + sizeof(*t)
356 #ifdef IP_SET_HASH_WITH_NETS
357                          + sizeof(struct net_prefixes) * nets_length
358 #endif
359                          + jhash_size(t->htable_bits) * sizeof(struct hbucket);
360 
361         for (i = 0; i < jhash_size(t->htable_bits); i++)
362                 memsize += t->bucket[i].size * h->dsize;
363 
364         return memsize;
365 }
366 
367 /* Flush a hash type of set: destroy all elements */
368 static void
369 mtype_flush(struct ip_set *set)
370 {
371         struct htype *h = set->data;
372         struct htable *t = h->table;
373         struct hbucket *n;
374         u32 i;
375 
376         for (i = 0; i < jhash_size(t->htable_bits); i++) {
377                 n = hbucket(t, i);
378                 if (n->size) {
379                         n->size = n->pos = 0;
380                         /* FIXME: use slab cache */
381                         kfree(n->value);
382                 }
383         }
384 #ifdef IP_SET_HASH_WITH_NETS
385         memset(h->nets, 0, sizeof(struct net_prefixes)
386                            * NETS_LENGTH(set->family));
387 #endif
388         h->elements = 0;
389 }
390 
391 /* Destroy a hash type of set */
392 static void
393 mtype_destroy(struct ip_set *set)
394 {
395         struct htype *h = set->data;
396 
397         if (set->extensions & IPSET_EXT_TIMEOUT)
398                 del_timer_sync(&h->gc);
399 
400         ahash_destroy(h->table);
401 #ifdef IP_SET_HASH_WITH_RBTREE
402         rbtree_destroy(&h->rbtree);
403 #endif
404         kfree(h);
405 
406         set->data = NULL;
407 }
408 
409 static void
410 mtype_gc_init(struct ip_set *set, void (*gc)(unsigned long ul_set))
411 {
412         struct htype *h = set->data;
413 
414         init_timer(&h->gc);
415         h->gc.data = (unsigned long) set;
416         h->gc.function = gc;
417         h->gc.expires = jiffies + IPSET_GC_PERIOD(h->timeout) * HZ;
418         add_timer(&h->gc);
419         pr_debug("gc initialized, run in every %u\n",
420                  IPSET_GC_PERIOD(h->timeout));
421 }
422 
423 static bool
424 mtype_same_set(const struct ip_set *a, const struct ip_set *b)
425 {
426         const struct htype *x = a->data;
427         const struct htype *y = b->data;
428 
429         /* Resizing changes htable_bits, so we ignore it */
430         return x->maxelem == y->maxelem &&
431                x->timeout == y->timeout &&
432 #ifdef IP_SET_HASH_WITH_NETMASK
433                x->netmask == y->netmask &&
434 #endif
435                a->extensions == b->extensions;
436 }
437 
438 /* Get the ith element from the array block n */
439 #define ahash_data(n, i, dsize) \
440         ((struct mtype_elem *)((n)->value + ((i) * (dsize))))
441 
442 /* Delete expired elements from the hashtable */
443 static void
444 mtype_expire(struct htype *h, u8 nets_length, size_t dsize)
445 {
446         struct htable *t = h->table;
447         struct hbucket *n;
448         struct mtype_elem *data;
449         u32 i;
450         int j;
451 
452         for (i = 0; i < jhash_size(t->htable_bits); i++) {
453                 n = hbucket(t, i);
454                 for (j = 0; j < n->pos; j++) {
455                         data = ahash_data(n, j, dsize);
456                         if (ip_set_timeout_expired(ext_timeout(data, h))) {
457                                 pr_debug("expired %u/%u\n", i, j);
458 #ifdef IP_SET_HASH_WITH_NETS
459                                 mtype_del_cidr(h, CIDR(data->cidr),
460                                                nets_length);
461 #endif
462                                 if (j != n->pos - 1)
463                                         /* Not last one */
464                                         memcpy(data,
465                                                ahash_data(n, n->pos - 1, dsize),
466                                                dsize);
467                                 n->pos--;
468                                 h->elements--;
469                         }
470                 }
471                 if (n->pos + AHASH_INIT_SIZE < n->size) {
472                         void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
473                                             * dsize,
474                                             GFP_ATOMIC);
475                         if (!tmp)
476                                 /* Still try to delete expired elements */
477                                 continue;
478                         n->size -= AHASH_INIT_SIZE;
479                         memcpy(tmp, n->value, n->size * dsize);
480                         kfree(n->value);
481                         n->value = tmp;
482                 }
483         }
484 }
485 
486 static void
487 mtype_gc(unsigned long ul_set)
488 {
489         struct ip_set *set = (struct ip_set *) ul_set;
490         struct htype *h = set->data;
491 
492         pr_debug("called\n");
493         write_lock_bh(&set->lock);
494         mtype_expire(h, NETS_LENGTH(set->family), h->dsize);
495         write_unlock_bh(&set->lock);
496 
497         h->gc.expires = jiffies + IPSET_GC_PERIOD(h->timeout) * HZ;
498         add_timer(&h->gc);
499 }
500 
501 /* Resize a hash: create a new hash table with doubling the hashsize
502  * and inserting the elements to it. Repeat until we succeed or
503  * fail due to memory pressures. */
504 static int
505 mtype_resize(struct ip_set *set, bool retried)
506 {
507         struct htype *h = set->data;
508         struct htable *t, *orig = h->table;
509         u8 htable_bits = orig->htable_bits;
510 #ifdef IP_SET_HASH_WITH_NETS
511         u8 flags;
512 #endif
513         struct mtype_elem *data;
514         struct mtype_elem *d;
515         struct hbucket *n, *m;
516         u32 i, j;
517         int ret;
518 
519         /* Try to cleanup once */
520         if (SET_WITH_TIMEOUT(set) && !retried) {
521                 i = h->elements;
522                 write_lock_bh(&set->lock);
523                 mtype_expire(set->data, NETS_LENGTH(set->family),
524                              h->dsize);
525                 write_unlock_bh(&set->lock);
526                 if (h->elements < i)
527                         return 0;
528         }
529 
530 retry:
531         ret = 0;
532         htable_bits++;
533         pr_debug("attempt to resize set %s from %u to %u, t %p\n",
534                  set->name, orig->htable_bits, htable_bits, orig);
535         if (!htable_bits) {
536                 /* In case we have plenty of memory :-) */
537                 pr_warning("Cannot increase the hashsize of set %s further\n",
538                            set->name);
539                 return -IPSET_ERR_HASH_FULL;
540         }
541         t = ip_set_alloc(sizeof(*t)
542                          + jhash_size(htable_bits) * sizeof(struct hbucket));
543         if (!t)
544                 return -ENOMEM;
545         t->htable_bits = htable_bits;
546 
547         read_lock_bh(&set->lock);
548         for (i = 0; i < jhash_size(orig->htable_bits); i++) {
549                 n = hbucket(orig, i);
550                 for (j = 0; j < n->pos; j++) {
551                         data = ahash_data(n, j, h->dsize);
552 #ifdef IP_SET_HASH_WITH_NETS
553                         flags = 0;
554                         mtype_data_reset_flags(data, &flags);
555 #endif
556                         m = hbucket(t, HKEY(data, h->initval, htable_bits));
557                         ret = hbucket_elem_add(m, AHASH_MAX(h), h->dsize);
558                         if (ret < 0) {
559 #ifdef IP_SET_HASH_WITH_NETS
560                                 mtype_data_reset_flags(data, &flags);
561 #endif
562                                 read_unlock_bh(&set->lock);
563                                 ahash_destroy(t);
564                                 if (ret == -EAGAIN)
565                                         goto retry;
566                                 return ret;
567                         }
568                         d = ahash_data(m, m->pos++, h->dsize);
569                         memcpy(d, data, h->dsize);
570 #ifdef IP_SET_HASH_WITH_NETS
571                         mtype_data_reset_flags(d, &flags);
572 #endif
573                 }
574         }
575 
576         rcu_assign_pointer(h->table, t);
577         read_unlock_bh(&set->lock);
578 
579         /* Give time to other readers of the set */
580         synchronize_rcu_bh();
581 
582         pr_debug("set %s resized from %u (%p) to %u (%p)\n", set->name,
583                  orig->htable_bits, orig, t->htable_bits, t);
584         ahash_destroy(orig);
585 
586         return 0;
587 }
588 
589 /* Add an element to a hash and update the internal counters when succeeded,
590  * otherwise report the proper error code. */
591 static int
592 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
593           struct ip_set_ext *mext, u32 flags)
594 {
595         struct htype *h = set->data;
596         struct htable *t;
597         const struct mtype_elem *d = value;
598         struct mtype_elem *data;
599         struct hbucket *n;
600         int i, ret = 0;
601         int j = AHASH_MAX(h) + 1;
602         bool flag_exist = flags & IPSET_FLAG_EXIST;
603         u32 key, multi = 0;
604 
605         if (SET_WITH_TIMEOUT(set) && h->elements >= h->maxelem)
606                 /* FIXME: when set is full, we slow down here */
607                 mtype_expire(h, NETS_LENGTH(set->family), h->dsize);
608 
609         if (h->elements >= h->maxelem) {
610                 if (net_ratelimit())
611                         pr_warning("Set %s is full, maxelem %u reached\n",
612                                    set->name, h->maxelem);
613                 return -IPSET_ERR_HASH_FULL;
614         }
615 
616         rcu_read_lock_bh();
617         t = rcu_dereference_bh(h->table);
618         key = HKEY(value, h->initval, t->htable_bits);
619         n = hbucket(t, key);
620         for (i = 0; i < n->pos; i++) {
621                 data = ahash_data(n, i, h->dsize);
622                 if (mtype_data_equal(data, d, &multi)) {
623                         if (flag_exist ||
624                             (SET_WITH_TIMEOUT(set) &&
625                              ip_set_timeout_expired(ext_timeout(data, h)))) {
626                                 /* Just the extensions could be overwritten */
627                                 j = i;
628                                 goto reuse_slot;
629                         } else {
630                                 ret = -IPSET_ERR_EXIST;
631                                 goto out;
632                         }
633                 }
634                 /* Reuse first timed out entry */
635                 if (SET_WITH_TIMEOUT(set) &&
636                     ip_set_timeout_expired(ext_timeout(data, h)) &&
637                     j != AHASH_MAX(h) + 1)
638                         j = i;
639         }
640 reuse_slot:
641         if (j != AHASH_MAX(h) + 1) {
642                 /* Fill out reused slot */
643                 data = ahash_data(n, j, h->dsize);
644 #ifdef IP_SET_HASH_WITH_NETS
645                 mtype_del_cidr(h, CIDR(data->cidr), NETS_LENGTH(set->family));
646                 mtype_add_cidr(h, CIDR(d->cidr), NETS_LENGTH(set->family));
647 #endif
648         } else {
649                 /* Use/create a new slot */
650                 TUNE_AHASH_MAX(h, multi);
651                 ret = hbucket_elem_add(n, AHASH_MAX(h), h->dsize);
652                 if (ret != 0) {
653                         if (ret == -EAGAIN)
654                                 mtype_data_next(&h->next, d);
655                         goto out;
656                 }
657                 data = ahash_data(n, n->pos++, h->dsize);
658 #ifdef IP_SET_HASH_WITH_NETS
659                 mtype_add_cidr(h, CIDR(d->cidr), NETS_LENGTH(set->family));
660 #endif
661                 h->elements++;
662         }
663         memcpy(data, d, sizeof(struct mtype_elem));
664 #ifdef IP_SET_HASH_WITH_NETS
665         mtype_data_set_flags(data, flags);
666 #endif
667         if (SET_WITH_TIMEOUT(set))
668                 ip_set_timeout_set(ext_timeout(data, h), ext->timeout);
669         if (SET_WITH_COUNTER(set))
670                 ip_set_init_counter(ext_counter(data, h), ext);
671 
672 out:
673         rcu_read_unlock_bh();
674         return ret;
675 }
676 
677 /* Delete an element from the hash: swap it with the last element
678  * and free up space if possible.
679  */
680 static int
681 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
682           struct ip_set_ext *mext, u32 flags)
683 {
684         struct htype *h = set->data;
685         struct htable *t = h->table;
686         const struct mtype_elem *d = value;
687         struct mtype_elem *data;
688         struct hbucket *n;
689         int i;
690         u32 key, multi = 0;
691 
692         key = HKEY(value, h->initval, t->htable_bits);
693         n = hbucket(t, key);
694         for (i = 0; i < n->pos; i++) {
695                 data = ahash_data(n, i, h->dsize);
696                 if (!mtype_data_equal(data, d, &multi))
697                         continue;
698                 if (SET_WITH_TIMEOUT(set) &&
699                     ip_set_timeout_expired(ext_timeout(data, h)))
700                         return -IPSET_ERR_EXIST;
701                 if (i != n->pos - 1)
702                         /* Not last one */
703                         memcpy(data, ahash_data(n, n->pos - 1, h->dsize),
704                                h->dsize);
705 
706                 n->pos--;
707                 h->elements--;
708 #ifdef IP_SET_HASH_WITH_NETS
709                 mtype_del_cidr(h, CIDR(d->cidr), NETS_LENGTH(set->family));
710 #endif
711                 if (n->pos + AHASH_INIT_SIZE < n->size) {
712                         void *tmp = kzalloc((n->size - AHASH_INIT_SIZE)
713                                             * h->dsize,
714                                             GFP_ATOMIC);
715                         if (!tmp)
716                                 return 0;
717                         n->size -= AHASH_INIT_SIZE;
718                         memcpy(tmp, n->value, n->size * h->dsize);
719                         kfree(n->value);
720                         n->value = tmp;
721                 }
722                 return 0;
723         }
724 
725         return -IPSET_ERR_EXIST;
726 }
727 
728 static inline int
729 mtype_data_match(struct mtype_elem *data, const struct ip_set_ext *ext,
730                  struct ip_set_ext *mext, struct ip_set *set, u32 flags)
731 {
732         if (SET_WITH_COUNTER(set))
733                 ip_set_update_counter(ext_counter(data,
734                                                   (struct htype *)(set->data)),
735                                       ext, mext, flags);
736         return mtype_do_data_match(data);
737 }
738 
739 #ifdef IP_SET_HASH_WITH_NETS
740 /* Special test function which takes into account the different network
741  * sizes added to the set */
742 static int
743 mtype_test_cidrs(struct ip_set *set, struct mtype_elem *d,
744                  const struct ip_set_ext *ext,
745                  struct ip_set_ext *mext, u32 flags)
746 {
747         struct htype *h = set->data;
748         struct htable *t = h->table;
749         struct hbucket *n;
750         struct mtype_elem *data;
751         int i, j = 0;
752         u32 key, multi = 0;
753         u8 nets_length = NETS_LENGTH(set->family);
754 
755         pr_debug("test by nets\n");
756         for (; j < nets_length && h->nets[j].nets && !multi; j++) {
757                 mtype_data_netmask(d, h->nets[j].cidr);
758                 key = HKEY(d, h->initval, t->htable_bits);
759                 n = hbucket(t, key);
760                 for (i = 0; i < n->pos; i++) {
761                         data = ahash_data(n, i, h->dsize);
762                         if (!mtype_data_equal(data, d, &multi))
763                                 continue;
764                         if (SET_WITH_TIMEOUT(set)) {
765                                 if (!ip_set_timeout_expired(
766                                                         ext_timeout(data, h)))
767                                         return mtype_data_match(data, ext,
768                                                                 mext, set,
769                                                                 flags);
770 #ifdef IP_SET_HASH_WITH_MULTI
771                                 multi = 0;
772 #endif
773                         } else
774                                 return mtype_data_match(data, ext,
775                                                         mext, set, flags);
776                 }
777         }
778         return 0;
779 }
780 #endif
781 
782 /* Test whether the element is added to the set */
783 static int
784 mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
785            struct ip_set_ext *mext, u32 flags)
786 {
787         struct htype *h = set->data;
788         struct htable *t = h->table;
789         struct mtype_elem *d = value;
790         struct hbucket *n;
791         struct mtype_elem *data;
792         int i;
793         u32 key, multi = 0;
794 
795 #ifdef IP_SET_HASH_WITH_NETS
796         /* If we test an IP address and not a network address,
797          * try all possible network sizes */
798         if (CIDR(d->cidr) == SET_HOST_MASK(set->family))
799                 return mtype_test_cidrs(set, d, ext, mext, flags);
800 #endif
801 
802         key = HKEY(d, h->initval, t->htable_bits);
803         n = hbucket(t, key);
804         for (i = 0; i < n->pos; i++) {
805                 data = ahash_data(n, i, h->dsize);
806                 if (mtype_data_equal(data, d, &multi) &&
807                     !(SET_WITH_TIMEOUT(set) &&
808                       ip_set_timeout_expired(ext_timeout(data, h))))
809                         return mtype_data_match(data, ext, mext, set, flags);
810         }
811         return 0;
812 }
813 
814 /* Reply a HEADER request: fill out the header part of the set */
815 static int
816 mtype_head(struct ip_set *set, struct sk_buff *skb)
817 {
818         const struct htype *h = set->data;
819         struct nlattr *nested;
820         size_t memsize;
821 
822         read_lock_bh(&set->lock);
823         memsize = mtype_ahash_memsize(h, NETS_LENGTH(set->family));
824         read_unlock_bh(&set->lock);
825 
826         nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
827         if (!nested)
828                 goto nla_put_failure;
829         if (nla_put_net32(skb, IPSET_ATTR_HASHSIZE,
830                           htonl(jhash_size(h->table->htable_bits))) ||
831             nla_put_net32(skb, IPSET_ATTR_MAXELEM, htonl(h->maxelem)))
832                 goto nla_put_failure;
833 #ifdef IP_SET_HASH_WITH_NETMASK
834         if (h->netmask != HOST_MASK &&
835             nla_put_u8(skb, IPSET_ATTR_NETMASK, h->netmask))
836                 goto nla_put_failure;
837 #endif
838         if (nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref - 1)) ||
839             nla_put_net32(skb, IPSET_ATTR_MEMSIZE, htonl(memsize)) ||
840             ((set->extensions & IPSET_EXT_TIMEOUT) &&
841              nla_put_net32(skb, IPSET_ATTR_TIMEOUT, htonl(h->timeout))) ||
842             ((set->extensions & IPSET_EXT_COUNTER) &&
843              nla_put_net32(skb, IPSET_ATTR_CADT_FLAGS,
844                            htonl(IPSET_FLAG_WITH_COUNTERS))))
845                 goto nla_put_failure;
846         ipset_nest_end(skb, nested);
847 
848         return 0;
849 nla_put_failure:
850         return -EMSGSIZE;
851 }
852 
853 /* Reply a LIST/SAVE request: dump the elements of the specified set */
854 static int
855 mtype_list(const struct ip_set *set,
856            struct sk_buff *skb, struct netlink_callback *cb)
857 {
858         const struct htype *h = set->data;
859         const struct htable *t = h->table;
860         struct nlattr *atd, *nested;
861         const struct hbucket *n;
862         const struct mtype_elem *e;
863         u32 first = cb->args[2];
864         /* We assume that one hash bucket fills into one page */
865         void *incomplete;
866         int i;
867 
868         atd = ipset_nest_start(skb, IPSET_ATTR_ADT);
869         if (!atd)
870                 return -EMSGSIZE;
871         pr_debug("list hash set %s\n", set->name);
872         for (; cb->args[2] < jhash_size(t->htable_bits); cb->args[2]++) {
873                 incomplete = skb_tail_pointer(skb);
874                 n = hbucket(t, cb->args[2]);
875                 pr_debug("cb->args[2]: %lu, t %p n %p\n", cb->args[2], t, n);
876                 for (i = 0; i < n->pos; i++) {
877                         e = ahash_data(n, i, h->dsize);
878                         if (SET_WITH_TIMEOUT(set) &&
879                             ip_set_timeout_expired(ext_timeout(e, h)))
880                                 continue;
881                         pr_debug("list hash %lu hbucket %p i %u, data %p\n",
882                                  cb->args[2], n, i, e);
883                         nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
884                         if (!nested) {
885                                 if (cb->args[2] == first) {
886                                         nla_nest_cancel(skb, atd);
887                                         return -EMSGSIZE;
888                                 } else
889                                         goto nla_put_failure;
890                         }
891                         if (mtype_data_list(skb, e))
892                                 goto nla_put_failure;
893                         if (SET_WITH_TIMEOUT(set) &&
894                             nla_put_net32(skb, IPSET_ATTR_TIMEOUT,
895                                           htonl(ip_set_timeout_get(
896                                                 ext_timeout(e, h)))))
897                                 goto nla_put_failure;
898                         if (SET_WITH_COUNTER(set) &&
899                             ip_set_put_counter(skb, ext_counter(e, h)))
900                                 goto nla_put_failure;
901                         ipset_nest_end(skb, nested);
902                 }
903         }
904         ipset_nest_end(skb, atd);
905         /* Set listing finished */
906         cb->args[2] = 0;
907 
908         return 0;
909 
910 nla_put_failure:
911         nlmsg_trim(skb, incomplete);
912         ipset_nest_end(skb, atd);
913         if (unlikely(first == cb->args[2])) {
914                 pr_warning("Can't list set %s: one bucket does not fit into "
915                            "a message. Please report it!\n", set->name);
916                 cb->args[2] = 0;
917                 return -EMSGSIZE;
918         }
919         return 0;
920 }
921 
922 static int
923 TOKEN(MTYPE, _kadt)(struct ip_set *set, const struct sk_buff *skb,
924               const struct xt_action_param *par,
925               enum ipset_adt adt, struct ip_set_adt_opt *opt);
926 
927 static int
928 TOKEN(MTYPE, _uadt)(struct ip_set *set, struct nlattr *tb[],
929               enum ipset_adt adt, u32 *lineno, u32 flags, bool retried);
930 
931 static const struct ip_set_type_variant mtype_variant = {
932         .kadt   = mtype_kadt,
933         .uadt   = mtype_uadt,
934         .adt    = {
935                 [IPSET_ADD] = mtype_add,
936                 [IPSET_DEL] = mtype_del,
937                 [IPSET_TEST] = mtype_test,
938         },
939         .destroy = mtype_destroy,
940         .flush  = mtype_flush,
941         .head   = mtype_head,
942         .list   = mtype_list,
943         .resize = mtype_resize,
944         .same_set = mtype_same_set,
945 };
946 
947 #ifdef IP_SET_EMIT_CREATE
948 static int
949 TOKEN(HTYPE, _create)(struct ip_set *set, struct nlattr *tb[], u32 flags)
950 {
951         u32 hashsize = IPSET_DEFAULT_HASHSIZE, maxelem = IPSET_DEFAULT_MAXELEM;
952         u32 cadt_flags = 0;
953         u8 hbits;
954 #ifdef IP_SET_HASH_WITH_NETMASK
955         u8 netmask;
956 #endif
957         size_t hsize;
958         struct HTYPE *h;
959 
960         if (!(set->family == NFPROTO_IPV4 || set->family == NFPROTO_IPV6))
961                 return -IPSET_ERR_INVALID_FAMILY;
962 #ifdef IP_SET_HASH_WITH_NETMASK
963         netmask = set->family == NFPROTO_IPV4 ? 32 : 128;
964         pr_debug("Create set %s with family %s\n",
965                  set->name, set->family == NFPROTO_IPV4 ? "inet" : "inet6");
966 #endif
967 
968         if (unlikely(!ip_set_optattr_netorder(tb, IPSET_ATTR_HASHSIZE) ||
969                      !ip_set_optattr_netorder(tb, IPSET_ATTR_MAXELEM) ||
970                      !ip_set_optattr_netorder(tb, IPSET_ATTR_TIMEOUT) ||
971                      !ip_set_optattr_netorder(tb, IPSET_ATTR_CADT_FLAGS)))
972                 return -IPSET_ERR_PROTOCOL;
973 
974         if (tb[IPSET_ATTR_HASHSIZE]) {
975                 hashsize = ip_set_get_h32(tb[IPSET_ATTR_HASHSIZE]);
976                 if (hashsize < IPSET_MIMINAL_HASHSIZE)
977                         hashsize = IPSET_MIMINAL_HASHSIZE;
978         }
979 
980         if (tb[IPSET_ATTR_MAXELEM])
981                 maxelem = ip_set_get_h32(tb[IPSET_ATTR_MAXELEM]);
982 
983 #ifdef IP_SET_HASH_WITH_NETMASK
984         if (tb[IPSET_ATTR_NETMASK]) {
985                 netmask = nla_get_u8(tb[IPSET_ATTR_NETMASK]);
986 
987                 if ((set->family == NFPROTO_IPV4 && netmask > 32) ||
988                     (set->family == NFPROTO_IPV6 && netmask > 128) ||
989                     netmask == 0)
990                         return -IPSET_ERR_INVALID_NETMASK;
991         }
992 #endif
993 
994         hsize = sizeof(*h);
995 #ifdef IP_SET_HASH_WITH_NETS
996         hsize += sizeof(struct net_prefixes) *
997                 (set->family == NFPROTO_IPV4 ? 32 : 128);
998 #endif
999         h = kzalloc(hsize, GFP_KERNEL);
1000         if (!h)
1001                 return -ENOMEM;
1002 
1003         h->maxelem = maxelem;
1004 #ifdef IP_SET_HASH_WITH_NETMASK
1005         h->netmask = netmask;
1006 #endif
1007         get_random_bytes(&h->initval, sizeof(h->initval));
1008         h->timeout = IPSET_NO_TIMEOUT;
1009 
1010         hbits = htable_bits(hashsize);
1011         hsize = htable_size(hbits);
1012         if (hsize == 0) {
1013                 kfree(h);
1014                 return -ENOMEM;
1015         }
1016         h->table = ip_set_alloc(hsize);
1017         if (!h->table) {
1018                 kfree(h);
1019                 return -ENOMEM;
1020         }
1021         h->table->htable_bits = hbits;
1022 
1023         set->data = h;
1024         if (set->family ==  NFPROTO_IPV4)
1025                 set->variant = &TOKEN(HTYPE, 4_variant);
1026         else
1027                 set->variant = &TOKEN(HTYPE, 6_variant);
1028 
1029         if (tb[IPSET_ATTR_CADT_FLAGS])
1030                 cadt_flags = ip_set_get_h32(tb[IPSET_ATTR_CADT_FLAGS]);
1031         if (cadt_flags & IPSET_FLAG_WITH_COUNTERS) {
1032                 set->extensions |= IPSET_EXT_COUNTER;
1033                 if (tb[IPSET_ATTR_TIMEOUT]) {
1034                         h->timeout =
1035                                 ip_set_timeout_uget(tb[IPSET_ATTR_TIMEOUT]);
1036                         set->extensions |= IPSET_EXT_TIMEOUT;
1037                         if (set->family == NFPROTO_IPV4) {
1038                                 h->dsize =
1039                                         sizeof(struct TOKEN(HTYPE, 4ct_elem));
1040                                 h->offset[IPSET_OFFSET_TIMEOUT] =
1041                                         offsetof(struct TOKEN(HTYPE, 4ct_elem),
1042                                                  timeout);
1043                                 h->offset[IPSET_OFFSET_COUNTER] =
1044                                         offsetof(struct TOKEN(HTYPE, 4ct_elem),
1045                                                  counter);
1046                                 TOKEN(HTYPE, 4_gc_init)(set,
1047                                         TOKEN(HTYPE, 4_gc));
1048                         } else {
1049                                 h->dsize =
1050                                         sizeof(struct TOKEN(HTYPE, 6ct_elem));
1051                                 h->offset[IPSET_OFFSET_TIMEOUT] =
1052                                         offsetof(struct TOKEN(HTYPE, 6ct_elem),
1053                                                  timeout);
1054                                 h->offset[IPSET_OFFSET_COUNTER] =
1055                                         offsetof(struct TOKEN(HTYPE, 6ct_elem),
1056                                                  counter);
1057                                 TOKEN(HTYPE, 6_gc_init)(set,
1058                                         TOKEN(HTYPE, 6_gc));
1059                         }
1060                 } else {
1061                         if (set->family == NFPROTO_IPV4) {
1062                                 h->dsize =
1063                                         sizeof(struct TOKEN(HTYPE, 4c_elem));
1064                                 h->offset[IPSET_OFFSET_COUNTER] =
1065                                         offsetof(struct TOKEN(HTYPE, 4c_elem),
1066                                                  counter);
1067                         } else {
1068                                 h->dsize =
1069                                         sizeof(struct TOKEN(HTYPE, 6c_elem));
1070                                 h->offset[IPSET_OFFSET_COUNTER] =
1071                                         offsetof(struct TOKEN(HTYPE, 6c_elem),
1072                                                  counter);
1073                         }
1074                 }
1075         } else if (tb[IPSET_ATTR_TIMEOUT]) {
1076                 h->timeout = ip_set_timeout_uget(tb[IPSET_ATTR_TIMEOUT]);
1077                 set->extensions |= IPSET_EXT_TIMEOUT;
1078                 if (set->family == NFPROTO_IPV4) {
1079                         h->dsize = sizeof(struct TOKEN(HTYPE, 4t_elem));
1080                         h->offset[IPSET_OFFSET_TIMEOUT] =
1081                                 offsetof(struct TOKEN(HTYPE, 4t_elem),
1082                                          timeout);
1083                         TOKEN(HTYPE, 4_gc_init)(set, TOKEN(HTYPE, 4_gc));
1084                 } else {
1085                         h->dsize = sizeof(struct TOKEN(HTYPE, 6t_elem));
1086                         h->offset[IPSET_OFFSET_TIMEOUT] =
1087                                 offsetof(struct TOKEN(HTYPE, 6t_elem),
1088                                          timeout);
1089                         TOKEN(HTYPE, 6_gc_init)(set, TOKEN(HTYPE, 6_gc));
1090                 }
1091         } else {
1092                 if (set->family == NFPROTO_IPV4)
1093                         h->dsize = sizeof(struct TOKEN(HTYPE, 4_elem));
1094                 else
1095                         h->dsize = sizeof(struct TOKEN(HTYPE, 6_elem));
1096         }
1097 
1098         pr_debug("create %s hashsize %u (%u) maxelem %u: %p(%p)\n",
1099                  set->name, jhash_size(h->table->htable_bits),
1100                  h->table->htable_bits, h->maxelem, set->data, h->table);
1101 
1102         return 0;
1103 }
1104 #endif /* IP_SET_EMIT_CREATE */
1105 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp