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_flush             IPSET_TOKEN(MTYPE, _flush)
  26 #define mtype_head              IPSET_TOKEN(MTYPE, _head)
  27 #define mtype_same_set          IPSET_TOKEN(MTYPE, _same_set)
  28 #define mtype_elem              IPSET_TOKEN(MTYPE, _elem)
  29 #define mtype_test              IPSET_TOKEN(MTYPE, _test)
  30 #define mtype_add               IPSET_TOKEN(MTYPE, _add)
  31 #define mtype_del               IPSET_TOKEN(MTYPE, _del)
  32 #define mtype_list              IPSET_TOKEN(MTYPE, _list)
  33 #define mtype_gc                IPSET_TOKEN(MTYPE, _gc)
  34 #define mtype                   MTYPE
  35
  36 #define get_ext(set, map, id)   ((map)->extensions + (set)->dsize * (id))
  37
  38 static void
  39 mtype_gc_init(struct ip_set *set, void (*gc)(unsigned long ul_set))
  40 {
  41         struct mtype *map = set->data;
  42
  43         init_timer(&map->gc);
  44         map->gc.data = (unsigned long)set;
  45         map->gc.function = gc;
  46         map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
  47         add_timer(&map->gc);
  48 }
  49
  50 static void
  51 mtype_ext_cleanup(struct ip_set *set)
  52 {
  53         struct mtype *map = set->data;
  54         u32 id;
  55
  56         for (id = 0; id < map->elements; id++)
  57                 if (test_bit(id, map->members))
  58                         ip_set_ext_destroy(set, get_ext(set, map, id));
  59 }
  60
  61 static void
  62 mtype_destroy(struct ip_set *set)
  63 {
  64         struct mtype *map = set->data;
  65
  66         if (SET_WITH_TIMEOUT(set))
  67                 del_timer_sync(&map->gc);
  68
  69         ip_set_free(map->members);
  70         if (set->dsize) {
  71                 if (set->extensions & IPSET_EXT_DESTROY)
  72                         mtype_ext_cleanup(set);
  73                 ip_set_free(map->extensions);
  74         }
  75         kfree(map);
  76
  77         set->data = NULL;
  78 }
  79
  80 static void
  81 mtype_flush(struct ip_set *set)
  82 {
  83         struct mtype *map = set->data;
  84
  85         if (set->extensions & IPSET_EXT_DESTROY)
  86                 mtype_ext_cleanup(set);
  87         memset(map->members, 0, map->memsize);
  88 }
  89
  90 static int
  91 mtype_head(struct ip_set *set, struct sk_buff *skb)
  92 {
  93         const struct mtype *map = set->data;
  94         struct nlattr *nested;
  95
  96         nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
  97         if (!nested)
  98                 goto nla_put_failure;
  99         if (mtype_do_head(skb, map) ||
 100             nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref - 1)) ||
 101             nla_put_net32(skb, IPSET_ATTR_MEMSIZE,
 102                           htonl(sizeof(*map) +
 103                                 map->memsize +
 104                                 set->dsize * map->elements)))
 105                 goto nla_put_failure;
 106         if (unlikely(ip_set_put_flags(skb, set)))
 107                 goto nla_put_failure;
 108         ipset_nest_end(skb, nested);
 109
 110         return 0;
 111 nla_put_failure:
 112         return -EMSGSIZE;
 113 }
 114
 115 static int
 116 mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 117            struct ip_set_ext *mext, u32 flags)
 118 {
 119         struct mtype *map = set->data;
 120         const struct mtype_adt_elem *e = value;
 121         void *x = get_ext(set, map, e->id);
 122         int ret = mtype_do_test(e, map, set->dsize);
 123
 124         if (ret <= 0)
 125                 return ret;
 126         if (SET_WITH_TIMEOUT(set) &&
 127             ip_set_timeout_expired(ext_timeout(x, set)))
 128                 return 0;
 129         if (SET_WITH_COUNTER(set))
 130                 ip_set_update_counter(ext_counter(x, set), ext, mext, flags);
 131         if (SET_WITH_SKBINFO(set))
 132                 ip_set_get_skbinfo(ext_skbinfo(x, set), ext, mext, flags);
 133         return 1;
 134 }
 135
 136 static int
 137 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 138           struct ip_set_ext *mext, u32 flags)
 139 {
 140         struct mtype *map = set->data;
 141         const struct mtype_adt_elem *e = value;
 142         void *x = get_ext(set, map, e->id);
 143         int ret = mtype_do_add(e, map, flags, set->dsize);
 144
 145         if (ret == IPSET_ADD_FAILED) {
 146                 if (SET_WITH_TIMEOUT(set) &&
 147                     ip_set_timeout_expired(ext_timeout(x, set))) {
 148                         ret = 0;
 149                 } else if (!(flags & IPSET_FLAG_EXIST)) {
 150                         set_bit(e->id, map->members);
 151                         return -IPSET_ERR_EXIST;
 152                 }
 153                 /* Element is re-added, cleanup extensions */
 154                 ip_set_ext_destroy(set, x);
 155         }
 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(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
 174         return 0;
 175 }
 176
 177 static int
 178 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 179           struct ip_set_ext *mext, u32 flags)
 180 {
 181         struct mtype *map = set->data;
 182         const struct mtype_adt_elem *e = value;
 183         void *x = get_ext(set, map, e->id);
 184
 185         if (mtype_do_del(e, map))
 186                 return -IPSET_ERR_EXIST;
 187
 188         ip_set_ext_destroy(set, x);
 189         if (SET_WITH_TIMEOUT(set) &&
 190             ip_set_timeout_expired(ext_timeout(x, set)))
 191                 return -IPSET_ERR_EXIST;
 192
 193         return 0;
 194 }
 195
 196 #ifndef IP_SET_BITMAP_STORED_TIMEOUT
 197 static inline bool
 198 mtype_is_filled(const struct mtype_elem *x)
 199 {
 200         return true;
 201 }
 202 #endif
 203
 204 static int
 205 mtype_list(const struct ip_set *set,
 206            struct sk_buff *skb, struct netlink_callback *cb)
 207 {
 208         struct mtype *map = set->data;
 209         struct nlattr *adt, *nested;
 210         void *x;
 211         u32 id, first = cb->args[IPSET_CB_ARG0];
 212         int ret = 0;
 213
 214         adt = ipset_nest_start(skb, IPSET_ATTR_ADT);
 215         if (!adt)
 216                 return -EMSGSIZE;
 217         /* Extensions may be replaced */
 218         rcu_read_lock();
 219         for (; cb->args[IPSET_CB_ARG0] < map->elements;
 220              cb->args[IPSET_CB_ARG0]++) {
 221                 id = cb->args[IPSET_CB_ARG0];
 222                 x = get_ext(set, map, id);
 223                 if (!test_bit(id, map->members) ||
 224                     (SET_WITH_TIMEOUT(set) &&
 225 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
 226                      mtype_is_filled((const struct mtype_elem *)x) &&
 227 #endif
 228                      ip_set_timeout_expired(ext_timeout(x, set))))
 229                         continue;
 230                 nested = ipset_nest_start(skb, IPSET_ATTR_DATA);
 231                 if (!nested) {
 232                         if (id == first) {
 233                                 nla_nest_cancel(skb, adt);
 234                                 ret = -EMSGSIZE;
 235                                 goto out;
 236                         }
 237
 238                         goto nla_put_failure;
 239                 }
 240                 if (mtype_do_list(skb, map, id, set->dsize))
 241                         goto nla_put_failure;
 242                 if (ip_set_put_extensions(skb, set, x,
 243                     mtype_is_filled((const struct mtype_elem *)x)))
 244                         goto nla_put_failure;
 245                 ipset_nest_end(skb, nested);
 246         }
 247         ipset_nest_end(skb, adt);
 248
 249         /* Set listing finished */
 250         cb->args[IPSET_CB_ARG0] = 0;
 251
 252         goto out;
 253
 254 nla_put_failure:
 255         nla_nest_cancel(skb, nested);
 256         if (unlikely(id == first)) {
 257                 cb->args[IPSET_CB_ARG0] = 0;
 258                 ret = -EMSGSIZE;
 259         }
 260         ipset_nest_end(skb, adt);
 261 out:
 262         rcu_read_unlock();
 263         return ret;
 264 }
 265
 266 static void
 267 mtype_gc(unsigned long ul_set)
 268 {
 269         struct ip_set *set = (struct ip_set *)ul_set;
 270         struct mtype *map = set->data;
 271         void *x;
 272         u32 id;
 273
 274         /* We run parallel with other readers (test element)
 275          * but adding/deleting new entries is locked out
 276          */
 277         spin_lock_bh(&set->lock);
 278         for (id = 0; id < map->elements; id++)
 279                 if (mtype_gc_test(id, map, set->dsize)) {
 280                         x = get_ext(set, map, id);
 281                         if (ip_set_timeout_expired(ext_timeout(x, set))) {
 282                                 clear_bit(id, map->members);
 283                                 ip_set_ext_destroy(set, x);
 284                         }
 285                 }
 286         spin_unlock_bh(&set->lock);
 287
 288         map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
 289         add_timer(&map->gc);
 290 }
 291
 292 static const struct ip_set_type_variant mtype = {
 293         .kadt   = mtype_kadt,
 294         .uadt   = mtype_uadt,
 295         .adt    = {
 296                 [IPSET_ADD] = mtype_add,
 297                 [IPSET_DEL] = mtype_del,
 298                 [IPSET_TEST] = mtype_test,
 299         },
 300         .destroy = mtype_destroy,
 301         .flush  = mtype_flush,
 302         .head   = mtype_head,
 303         .list   = mtype_list,
 304         .same_set = mtype_same_set,
 305 };
 306
 307 #endif /* __IP_SET_BITMAP_IP_GEN_H */