net/netfilter/ipset/ip_set_bitmap_gen.h

   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
  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
  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
  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
  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
  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
  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
 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         if (SET_WITH_TIMEOUT(set) &&
 131             ip_set_timeout_expired(ext_timeout(x, set)))
 132                 return 0;
 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);
 137         return 1;
 138 }
 139
 140 static int
 141 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 142           struct ip_set_ext *mext, u32 flags)
 143 {
 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);
 148
 149         if (ret == IPSET_ADD_FAILED) {
 150                 if (SET_WITH_TIMEOUT(set) &&
 151                     ip_set_timeout_expired(ext_timeout(x, set))) {
 152                         set->elements--;
 153                         ret = 0;
 154                 } else if (!(flags & IPSET_FLAG_EXIST)) {
 155                         set_bit(e->id, map->members);
 156                         return -IPSET_ERR_EXIST;
 157                 }
 158                 /* Element is re-added, cleanup extensions */
 159                 ip_set_ext_destroy(set, x);
 160         }
 161         if (ret > 0)
 162                 set->elements--;
 163
 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);
 167 #else
 168                 ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
 169 #endif
 170
 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);
 177
 178         /* Activate element */
 179         set_bit(e->id, map->members);
 180         set->elements++;
 181
 182         return 0;
 183 }
 184
 185 static int
 186 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 187           struct ip_set_ext *mext, u32 flags)
 188 {
 189         struct mtype *map = set->data;
 190         const struct mtype_adt_elem *e = value;
 191         void *x = get_ext(set, map, e->id);
 192
 193         if (mtype_do_del(e, map))
 194                 return -IPSET_ERR_EXIST;
 195
 196         ip_set_ext_destroy(set, x);
 197         set->elements--;
 198         if (SET_WITH_TIMEOUT(set) &&
 199             ip_set_timeout_expired(ext_timeout(x, set)))
 200                 return -IPSET_ERR_EXIST;
 201
 202         return 0;
 203 }
 204
 205 #ifndef IP_SET_BITMAP_STORED_TIMEOUT
 206 static inline bool
 207 mtype_is_filled(const struct mtype_elem *x)
 208 {
 209         return true;
 210 }
 211 #endif
 212
 213 static int
 214 mtype_list(const struct ip_set *set,
 215            struct sk_buff *skb, struct netlink_callback *cb)
 216 {
 217         struct mtype *map = set->data;
 218         struct nlattr *adt, *nested;
 219         void *x;
 220         u32 id, first = cb->args[IPSET_CB_ARG0];
 221         int ret = 0;
 222
 223         adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
 224         if (!adt)
 225                 return -EMSGSIZE;
 226         /* Extensions may be replaced */
 227         rcu_read_lock();
 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) &&
 236 #endif
 237                      ip_set_timeout_expired(ext_timeout(x, set))))
 238                         continue;
 239                 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
 240                 if (!nested) {
 241                         if (id == first) {
 242                                 nla_nest_cancel(skb, adt);
 243                                 ret = -EMSGSIZE;
 244                                 goto out;
 245                         }
 246
 247                         goto nla_put_failure;
 248                 }
 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);
 254         }
 255         ipset_nest_end(skb, adt);
 256
 257         /* Set listing finished */
 258         cb->args[IPSET_CB_ARG0] = 0;
 259
 260         goto out;
 261
 262 nla_put_failure:
 263         nla_nest_cancel(skb, nested);
 264         if (unlikely(id == first)) {
 265                 cb->args[IPSET_CB_ARG0] = 0;
 266                 ret = -EMSGSIZE;
 267         }
 268         ipset_nest_end(skb, adt);
 269 out:
 270         rcu_read_unlock();
 271         return ret;
 272 }
 273
 274 static void
 275 mtype_gc(struct timer_list *t)
 276 {
 277         struct mtype *map = from_timer(map, t, gc);
 278         struct ip_set *set = map->set;
 279         void *x;
 280         u32 id;
 281
 282         /* We run parallel with other readers (test element)
 283          * but adding/deleting new entries is locked out
 284          */
 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);
 292                                 set->elements--;
 293                         }
 294                 }
 295         spin_unlock_bh(&set->lock);
 296
 297         map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
 298         add_timer(&map->gc);
 299 }
 300
 301 static const struct ip_set_type_variant mtype = {
 302         .kadt   = mtype_kadt,
 303         .uadt   = mtype_uadt,
 304         .adt    = {
 305                 [IPSET_ADD] = mtype_add,
 306                 [IPSET_DEL] = mtype_del,
 307                 [IPSET_TEST] = mtype_test,
 308         },
 309         .destroy = mtype_destroy,
 310         .flush  = mtype_flush,
 311         .head   = mtype_head,
 312         .list   = mtype_list,
 313         .same_set = mtype_same_set,
 314 };
 315
 316 #endif /* __IP_SET_BITMAP_IP_GEN_H */