src/ct_cpusched.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * By Daniel Borkmann <daniel@netsniff-ng.org>
   4  * Copyright 2011 Daniel Borkmann.
   5  * Subject to the GPL, version 2.
   6  */
   7
   8 #define _GNU_SOURCE
   9 #include <search.h>
  10 #include <limits.h>
  11 #include <errno.h>
  12 #include <string.h>
  13
  14 #include "locking.h"
  15 #include "ct_cpusched.h"
  16 #include "xmalloc.h"
  17 #include "hash.h"
  18
  19 /* Flow to CPU mapper / scheduler to keep connection CPU-local */
  20 struct map_entry {
  21         int fd;
  22         unsigned int cpu;
  23         struct map_entry *next;
  24 };
  25
  26 static struct hash_table mapper;
  27 static unsigned int *cpu_assigned = NULL;
  28 static unsigned int cpu_len = 0;
  29 static struct rwlock map_lock;
  30
  31 void init_cpusched(unsigned int cpus)
  32 {
  33         rwlock_init(&map_lock);
  34
  35         rwlock_wr_lock(&map_lock);
  36
  37         cpu_len = cpus;
  38         cpu_assigned = xzmalloc(cpus * sizeof(*cpu_assigned));
  39
  40         memset(&mapper, 0, sizeof(mapper));
  41         init_hash(&mapper);
  42
  43         rwlock_unlock(&map_lock);
  44 }
  45
  46 static int get_appropriate_cpu(void)
  47 {
  48         int i, cpu = 0;
  49         int work = INT_MAX;
  50
  51         for (i = 0; i < cpu_len; ++i) {
  52                 if (cpu_assigned[i] < work) {
  53                         work = cpu_assigned[i];
  54                         cpu = i;
  55                 }
  56         }
  57
  58         return cpu;
  59 }
  60
  61 unsigned int socket_to_cpu(int fd)
  62 {
  63         int cpu = 0;
  64         struct map_entry *entry;
  65
  66         errno = 0;
  67
  68         rwlock_rd_lock(&map_lock);
  69
  70         entry = lookup_hash(fd, &mapper);
  71         while (entry && fd != entry->fd)
  72                 entry = entry->next;
  73         if (entry && fd == entry->fd)
  74                 cpu = entry->cpu;
  75         else
  76                 errno = ENOENT;
  77
  78         rwlock_unlock(&map_lock);
  79
  80         return cpu;
  81 }
  82
  83 unsigned int register_socket(int fd)
  84 {
  85         void **pos;
  86         struct map_entry *entry;
  87
  88         rwlock_wr_lock(&map_lock);
  89
  90         entry = xzmalloc(sizeof(*entry));
  91         entry->fd = fd;
  92         entry->cpu = get_appropriate_cpu();
  93
  94         cpu_assigned[entry->cpu]++;
  95
  96         pos = insert_hash(entry->fd, entry, &mapper);
  97         if (pos) {
  98                 entry->next = (*pos);
  99                 (*pos) = entry;
 100         }
 101
 102         rwlock_unlock(&map_lock);
 103
 104         return entry->cpu;
 105 }
 106
 107 static struct map_entry *socket_to_map_entry(int fd)
 108 {
 109         struct map_entry *entry, *ret = NULL;
 110
 111         errno = 0;
 112
 113         rwlock_rd_lock(&map_lock);
 114
 115         entry = lookup_hash(fd, &mapper);
 116         while (entry && fd != entry->fd)
 117                 entry = entry->next;
 118         if (entry && fd == entry->fd)
 119                 ret = entry;
 120         else
 121                 errno = ENOENT;
 122
 123         rwlock_unlock(&map_lock);
 124
 125         return ret;
 126 }
 127
 128 void unregister_socket(int fd)
 129 {
 130         struct map_entry *pos;
 131         struct map_entry *entry = socket_to_map_entry(fd);
 132
 133         if (!entry == 0 && errno == ENOENT)
 134                 return;
 135
 136         rwlock_wr_lock(&map_lock);
 137
 138         cpu_assigned[entry->cpu]--;
 139
 140         pos = remove_hash(entry->fd, entry, entry->next, &mapper);
 141         while (pos && pos->next && pos->next != entry)
 142                 pos = pos->next;
 143         if (pos && pos->next && pos->next == entry)
 144                 pos->next = entry->next;
 145
 146         entry->next = NULL;
 147         xfree(entry);
 148
 149         rwlock_unlock(&map_lock);
 150 }
 151
 152 static int cleanup_batch(void *ptr)
 153 {
 154         struct map_entry *next;
 155         struct map_entry *e = ptr;
 156
 157         if (!e)
 158                 return 0;
 159
 160         while ((next = e->next)) {
 161                 e->next = NULL;
 162                 xfree(e);
 163                 e = next;
 164         }
 165
 166         xfree(e);
 167
 168         return 0;
 169 }
 170
 171 void destroy_cpusched(void)
 172 {
 173         rwlock_wr_lock(&map_lock);
 174
 175         xfree(cpu_assigned);
 176         cpu_len = 0;
 177         for_each_hash(&mapper, cleanup_batch);
 178         free_hash(&mapper);
 179
 180         rwlock_unlock(&map_lock);
 181
 182         rwlock_destroy(&map_lock);
 183 }