net/netfilter/ipset/ip_set_bitmap_gen.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /* Copyright (C) 2013 Jozsef Kadlecsik <kadlec@netfilter.org> */
   3
   4 #ifndef __IP_SET_BITMAP_IP_GEN_H
   5 #define __IP_SET_BITMAP_IP_GEN_H
   6
   7 #include <linux/rcupdate_wait.h>
   8
   9 #define mtype_do_test           IPSET_TOKEN(MTYPE, _do_test)
  10 #define mtype_gc_test           IPSET_TOKEN(MTYPE, _gc_test)
  11 #define mtype_is_filled         IPSET_TOKEN(MTYPE, _is_filled)
  12 #define mtype_do_add            IPSET_TOKEN(MTYPE, _do_add)
  13 #define mtype_ext_cleanup       IPSET_TOKEN(MTYPE, _ext_cleanup)
  14 #define mtype_do_del            IPSET_TOKEN(MTYPE, _do_del)
  15 #define mtype_do_list           IPSET_TOKEN(MTYPE, _do_list)
  16 #define mtype_do_head           IPSET_TOKEN(MTYPE, _do_head)
  17 #define mtype_adt_elem          IPSET_TOKEN(MTYPE, _adt_elem)
  18 #define mtype_add_timeout       IPSET_TOKEN(MTYPE, _add_timeout)
  19 #define mtype_gc_init           IPSET_TOKEN(MTYPE, _gc_init)
  20 #define mtype_kadt              IPSET_TOKEN(MTYPE, _kadt)
  21 #define mtype_uadt              IPSET_TOKEN(MTYPE, _uadt)
  22 #define mtype_destroy           IPSET_TOKEN(MTYPE, _destroy)
  23 #define mtype_memsize           IPSET_TOKEN(MTYPE, _memsize)
  24 #define mtype_flush             IPSET_TOKEN(MTYPE, _flush)
  25 #define mtype_head              IPSET_TOKEN(MTYPE, _head)
  26 #define mtype_same_set          IPSET_TOKEN(MTYPE, _same_set)
  27 #define mtype_elem              IPSET_TOKEN(MTYPE, _elem)
  28 #define mtype_test              IPSET_TOKEN(MTYPE, _test)
  29 #define mtype_add               IPSET_TOKEN(MTYPE, _add)
  30 #define mtype_del               IPSET_TOKEN(MTYPE, _del)
  31 #define mtype_list              IPSET_TOKEN(MTYPE, _list)
  32 #define mtype_gc                IPSET_TOKEN(MTYPE, _gc)
  33 #define mtype                   MTYPE
  34
  35 #define get_ext(set, map, id)   ((map)->extensions + ((set)->dsize * (id)))
  36
  37 static void
  38 mtype_gc_init(struct ip_set *set, void (*gc)(struct timer_list *t))
  39 {
  40         struct mtype *map = set->data;
  41
  42         timer_setup(&map->gc, gc, 0);
  43         mod_timer(&map->gc, jiffies + IPSET_GC_PERIOD(set->timeout) * HZ);
  44 }
  45
  46 static void
  47 mtype_ext_cleanup(struct ip_set *set)
  48 {
  49         struct mtype *map = set->data;
  50         u32 id;
  51
  52         for (id = 0; id < map->elements; id++)
  53                 if (test_bit(id, map->members))
  54                         ip_set_ext_destroy(set, get_ext(set, map, id));
  55 }
  56
  57 static void
  58 mtype_destroy(struct ip_set *set)
  59 {
  60         struct mtype *map = set->data;
  61
  62         if (SET_WITH_TIMEOUT(set))
  63                 del_timer_sync(&map->gc);
  64
  65         if (set->dsize && set->extensions & IPSET_EXT_DESTROY)
  66                 mtype_ext_cleanup(set);
  67         ip_set_free(map->members);
  68         ip_set_free(map);
  69
  70         set->data = NULL;
  71 }
  72
  73 static void
  74 mtype_flush(struct ip_set *set)
  75 {
  76         struct mtype *map = set->data;
  77
  78         if (set->extensions & IPSET_EXT_DESTROY)
  79                 mtype_ext_cleanup(set);
  80         bitmap_zero(map->members, map->elements);
  81         set->elements = 0;
  82         set->ext_size = 0;
  83 }
  84
  85 /* Calculate the actual memory size of the set data */
  86 static size_t
  87 mtype_memsize(const struct mtype *map, size_t dsize)
  88 {
  89         return sizeof(*map) + map->memsize +
  90                map->elements * dsize;
  91 }
  92
  93 static int
  94 mtype_head(struct ip_set *set, struct sk_buff *skb)
  95 {
  96         const struct mtype *map = set->data;
  97         struct nlattr *nested;
  98         size_t memsize = mtype_memsize(map, set->dsize) + set->ext_size;
  99
 100         nested = nla_nest_start(skb, IPSET_ATTR_DATA);
 101         if (!nested)
 102                 goto nla_put_failure;
 103         if (mtype_do_head(skb, map) ||
 104             nla_put_net32(skb, IPSET_ATTR_REFERENCES, htonl(set->ref)) ||
 105             nla_put_net32(skb, IPSET_ATTR_MEMSIZE, htonl(memsize)) ||
 106             nla_put_net32(skb, IPSET_ATTR_ELEMENTS, htonl(set->elements)))
 107                 goto nla_put_failure;
 108         if (unlikely(ip_set_put_flags(skb, set)))
 109                 goto nla_put_failure;
 110         nla_nest_end(skb, nested);
 111
 112         return 0;
 113 nla_put_failure:
 114         return -EMSGSIZE;
 115 }
 116
 117 static int
 118 mtype_test(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 119            struct ip_set_ext *mext, u32 flags)
 120 {
 121         struct mtype *map = set->data;
 122         const struct mtype_adt_elem *e = value;
 123         void *x = get_ext(set, map, e->id);
 124         int ret = mtype_do_test(e, map, set->dsize);
 125
 126         if (ret <= 0)
 127                 return ret;
 128         return ip_set_match_extensions(set, ext, mext, flags, x);
 129 }
 130
 131 static int
 132 mtype_add(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 133           struct ip_set_ext *mext, u32 flags)
 134 {
 135         struct mtype *map = set->data;
 136         const struct mtype_adt_elem *e = value;
 137         void *x = get_ext(set, map, e->id);
 138         int ret = mtype_do_add(e, map, flags, set->dsize);
 139
 140         if (ret == IPSET_ADD_FAILED) {
 141                 if (SET_WITH_TIMEOUT(set) &&
 142                     ip_set_timeout_expired(ext_timeout(x, set))) {
 143                         set->elements--;
 144                         ret = 0;
 145                 } else if (!(flags & IPSET_FLAG_EXIST)) {
 146                         set_bit(e->id, map->members);
 147                         return -IPSET_ERR_EXIST;
 148                 }
 149                 /* Element is re-added, cleanup extensions */
 150                 ip_set_ext_destroy(set, x);
 151         }
 152         if (ret > 0)
 153                 set->elements--;
 154
 155         if (SET_WITH_TIMEOUT(set))
 156 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
 157                 mtype_add_timeout(ext_timeout(x, set), e, ext, set, map, ret);
 158 #else
 159                 ip_set_timeout_set(ext_timeout(x, set), ext->timeout);
 160 #endif
 161
 162         if (SET_WITH_COUNTER(set))
 163                 ip_set_init_counter(ext_counter(x, set), ext);
 164         if (SET_WITH_COMMENT(set))
 165                 ip_set_init_comment(set, ext_comment(x, set), ext);
 166         if (SET_WITH_SKBINFO(set))
 167                 ip_set_init_skbinfo(ext_skbinfo(x, set), ext);
 168
 169         /* Activate element */
 170         set_bit(e->id, map->members);
 171         set->elements++;
 172
 173         return 0;
 174 }
 175
 176 static int
 177 mtype_del(struct ip_set *set, void *value, const struct ip_set_ext *ext,
 178           struct ip_set_ext *mext, u32 flags)
 179 {
 180         struct mtype *map = set->data;
 181         const struct mtype_adt_elem *e = value;
 182         void *x = get_ext(set, map, e->id);
 183
 184         if (mtype_do_del(e, map))
 185                 return -IPSET_ERR_EXIST;
 186
 187         ip_set_ext_destroy(set, x);
 188         set->elements--;
 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 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 = nla_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                 cond_resched_rcu();
 222                 id = cb->args[IPSET_CB_ARG0];
 223                 x = get_ext(set, map, id);
 224                 if (!test_bit(id, map->members) ||
 225                     (SET_WITH_TIMEOUT(set) &&
 226 #ifdef IP_SET_BITMAP_STORED_TIMEOUT
 227                      mtype_is_filled(x) &&
 228 #endif
 229                      ip_set_timeout_expired(ext_timeout(x, set))))
 230                         continue;
 231                 nested = nla_nest_start(skb, IPSET_ATTR_DATA);
 232                 if (!nested) {
 233                         if (id == first) {
 234                                 nla_nest_cancel(skb, adt);
 235                                 ret = -EMSGSIZE;
 236                                 goto out;
 237                         }
 238
 239                         goto nla_put_failure;
 240                 }
 241                 if (mtype_do_list(skb, map, id, set->dsize))
 242                         goto nla_put_failure;
 243                 if (ip_set_put_extensions(skb, set, x, mtype_is_filled(x)))
 244                         goto nla_put_failure;
 245                 nla_nest_end(skb, nested);
 246         }
 247         nla_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         nla_nest_end(skb, adt);
 261 out:
 262         rcu_read_unlock();
 263         return ret;
 264 }
 265
 266 static void
 267 mtype_gc(struct timer_list *t)
 268 {
 269         struct mtype *map = from_timer(map, t, gc);
 270         struct ip_set *set = map->set;
 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                                 set->elements--;
 285                         }
 286                 }
 287         spin_unlock_bh(&set->lock);
 288
 289         map->gc.expires = jiffies + IPSET_GC_PERIOD(set->timeout) * HZ;
 290         add_timer(&map->gc);
 291 }
 292
 293 static const struct ip_set_type_variant mtype = {
 294         .kadt   = mtype_kadt,
 295         .uadt   = mtype_uadt,
 296         .adt    = {
 297                 [IPSET_ADD] = mtype_add,
 298                 [IPSET_DEL] = mtype_del,
 299                 [IPSET_TEST] = mtype_test,
 300         },
 301         .destroy = mtype_destroy,
 302         .flush  = mtype_flush,
 303         .head   = mtype_head,
 304         .list   = mtype_list,
 305         .same_set = mtype_same_set,
 306 };
 307
 308 #endif /* __IP_SET_BITMAP_IP_GEN_H */