+struct {
+ __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+ __uint(max_entries, RULECNT + STATIC_RULE_CNT);
+ __u32 *key;
+ struct match_counter *value;
+} drop_cnt_map SEC(".maps");
+
+#define INCREMENT_MATCH(reason) { \
+ struct match_counter *value = bpf_map_lookup_elem(&drop_cnt_map, &reason); \
+ if (value) { \
+ value->bytes += data_end - pktdata; \
+ value->packets += 1; \
+ } \
+}
+
+// Rate limits are done in a static-sized leaky bucket with a decimal counter
+// Bucket size is always exactly (1 << RATE_BUCKET_INTEGER_BITS)
+#define RATE_BUCKET_DECIMAL_BITS 8
+#define RATE_BUCKET_INTEGER_BITS 4
+
+#define RATE_BUCKET_BITS (RATE_BUCKET_DECIMAL_BITS + RATE_BUCKET_INTEGER_BITS)
+#define RATE_TIME_MASK ((1ULL << (64 - RATE_BUCKET_BITS)) - 1)
+
+// Time going backwards 10ms+ or forward 32sec+ implies we should consider it
+// an overflow, or at least stale enough that we should reset the entry.
+#define RATE_MIN_TIME_OFFSET -10000000LL
+#define RATE_MAX_TIME_OFFSET 32000000000LL
+
+#ifdef RATE_CNT
+struct ratelimit {
+ struct bpf_spin_lock lock;
+ uint64_t sent_time;
+};
+struct {
+ __uint(type, BPF_MAP_TYPE_ARRAY);
+ __uint(max_entries, RATE_CNT);
+ __u32 *key;
+ struct ratelimit *value;
+} rate_map SEC(".maps");
+#endif /* RATE_CNT */
+
+// We implement a rather naive hashtable here instead of using a BPF map because
+// (a) the BPF map hashtables are similarly naive (no rehashing, etc),
+// (b) the BPF map LRU hashtables don't support locking.
+//
+// We first separate into a few top-level buckets with per-bucket locks, limiting
+// us to 2^SRC_HASH_MAX_PARALLELISM parallel accessors.
+//
+// Then we build an array of MAX_ENTRIES/2**SRC_HASH_MAX_PARALLELISM_POW entries,
+// which are split into buckets of size SRC_HASH_BUCKET_COUNT. An entry can appear
+// in any of the SRC_HASH_BUCKET_COUNT buckets at it's hash value.
+#define SRC_HASH_MAX_PARALLELISM_POW 9
+#define SRC_HASH_MAX_PARALLELISM (1 << SRC_HASH_MAX_PARALLELISM_POW)
+#define SRC_HASH_BUCKET_COUNT_POW 3
+#define SRC_HASH_BUCKET_COUNT (1 << SRC_HASH_BUCKET_COUNT_POW)
+
+#include "rand.h"
+
+#define CREATE_PERSRC_LOOKUP(IPV, IP_TYPE) \
+struct persrc_rate##IPV##_entry { \
+ uint64_t sent_time; \
+ IP_TYPE srcip; \
+}; \
+ \
+struct persrc_rate##IPV##_bucket { \
+ struct bpf_spin_lock lock; \
+ struct persrc_rate##IPV##_entry entries[]; \
+}; \
+ \
+struct persrc_rate##IPV##_ptr { \
+ struct persrc_rate##IPV##_entry *rate; \
+ struct bpf_spin_lock *lock; \
+}; \
+ \
+__attribute__((always_inline)) \
+static inline struct persrc_rate##IPV##_ptr get_v##IPV##_persrc_ratelimit(IP_TYPE key, void *map, size_t map_limit, int64_t cur_time_masked) { \
+ struct persrc_rate##IPV##_ptr res = { .rate = NULL, .lock = NULL }; \
+ uint64_t hash = siphash(&key, sizeof(key), COMPILE_TIME_RAND); \
+ \
+ const uint32_t map_key = hash % SRC_HASH_MAX_PARALLELISM; \
+ struct persrc_rate##IPV##_bucket *buckets = bpf_map_lookup_elem(map, &map_key); \
+ if (!buckets) return res; \
+ \
+ hash >>= SRC_HASH_MAX_PARALLELISM_POW; \
+ map_limit >>= SRC_HASH_MAX_PARALLELISM_POW; \
+ \
+ struct persrc_rate##IPV##_entry *first_bucket = &buckets->entries[(hash % map_limit) & (~(SRC_HASH_BUCKET_COUNT - 1))]; \
+ bpf_spin_lock(&buckets->lock); \
+ \
+ int min_sent_idx = 0; \
+ uint64_t min_sent_time = UINT64_MAX; \
+ for (int i = 0; i < SRC_HASH_BUCKET_COUNT; i++) { \
+ if (first_bucket[i].srcip == key) { \
+ res.rate = &first_bucket[i]; \
+ res.lock = &buckets->lock; \
+ return res; \