oscam-garbage.c

   1 #define MODULE_LOG_PREFIX "gc"
   2
   3 #include "globals.h"
   4 #include "oscam-garbage.h"
   5 #include "oscam-lock.h"
   6 #include "oscam-string.h"
   7 #include "oscam-time.h"
   8
   9 #define HASH_BUCKETS 250
  10
  11 struct cs_garbage
  12 {
  13         time_t time;
  14         void *data;
  15 #ifdef WITH_DEBUG
  16         char *file;
  17         uint32_t line;
  18 #endif
  19         struct cs_garbage *next;
  20 };
  21
  22 static int32_t counter = 0;
  23 static pthread_mutex_t add_lock;
  24 static struct cs_garbage *garbage_first[HASH_BUCKETS];
  25 static CS_MUTEX_LOCK garbage_lock[HASH_BUCKETS];
  26 static pthread_t garbage_thread;
  27 static int32_t garbage_collector_active;
  28 static int32_t garbage_debug;
  29
  30 #ifdef WITH_DEBUG
  31 void add_garbage_debug(void *data, char *file, uint32_t line)
  32 {
  33 #else
  34 void add_garbage(void *data)
  35 {
  36 #endif
  37         if(!data)
  38                 { return; }
  39
  40         if(!garbage_collector_active || garbage_debug == 1)
  41         {
  42                 NULLFREE(data);
  43                 return;
  44         }
  45
  46         SAFE_MUTEX_LOCK(&add_lock);
  47
  48         int32_t bucket = counter++;
  49
  50         if(counter >= HASH_BUCKETS)
  51         {
  52                 counter = 0;
  53         }
  54
  55         SAFE_MUTEX_UNLOCK(&add_lock);
  56
  57         struct cs_garbage *garbage = (struct cs_garbage*)malloc(sizeof(struct cs_garbage));
  58         if(garbage == NULL)
  59         {
  60                 cs_log("*** MEMORY FULL -> FREEING DIRECT MAY LEAD TO INSTABILITY!!! ***");
  61                 NULLFREE(data);
  62                 return;
  63         }
  64         garbage->time = time(NULL);
  65         garbage->data = data;
  66         garbage->next = NULL;
  67 #ifdef WITH_DEBUG
  68         garbage->file = file;
  69         garbage->line = line;
  70 #endif
  71
  72         cs_writelock(__func__, &garbage_lock[bucket]);
  73
  74 #ifdef WITH_DEBUG
  75         if(garbage_debug == 2)
  76         {
  77                 struct cs_garbage *garbagecheck = garbage_first[bucket];
  78                 while(garbagecheck)
  79                 {
  80                         if(garbagecheck->data == data)
  81                         {
  82                                 cs_log("Found a try to add garbage twice. Not adding the element to garbage list...");
  83                                 cs_log("Current garbage addition: %s, line %d.", file, line);
  84                                 cs_log("Original garbage addition: %s, line %d.", garbagecheck->file, garbagecheck->line);
  85                                 cs_writeunlock(__func__, &garbage_lock[bucket]);
  86                                 NULLFREE(garbage);
  87                                 return;
  88                         }
  89                         garbagecheck = garbagecheck->next;
  90                 }
  91         }
  92 #endif
  93
  94         garbage->next = garbage_first[bucket];
  95         garbage_first[bucket] = garbage;
  96
  97         cs_writeunlock(__func__, &garbage_lock[bucket]);
  98 }
  99
 100 static pthread_cond_t sleep_cond;
 101 static pthread_mutex_t sleep_cond_mutex;
 102
 103 static void garbage_collector(void)
 104 {
 105         int32_t i,j;
 106         struct cs_garbage *garbage, *next, *prev, *first;
 107         set_thread_name(__func__);
 108         int32_t timeout_time = 2 * cfg.ctimeout / 1000 + 6;
 109
 110         while(garbage_collector_active)
 111         {
 112                 time_t deltime = time(NULL) - timeout_time;
 113
 114                 for(i = 0; i < HASH_BUCKETS; ++i)
 115                 {
 116                         j = 0;
 117                         cs_writelock(__func__, &garbage_lock[i]);
 118                         first = garbage_first[i];
 119
 120                         for(garbage = first, prev = NULL; garbage; prev = garbage, garbage = garbage->next, j++)
 121                         {
 122                                 if(j == 2)
 123                                 {
 124                                         j++;
 125                                         cs_writeunlock(__func__, &garbage_lock[i]);
 126                                 }
 127
 128                                 if(garbage->time < deltime) // all following elements are too new
 129                                 {
 130                                         if(prev)
 131                                         {
 132                                                 prev->next = NULL;
 133                                         }
 134                                         else
 135                                         {
 136                                                 garbage_first[i] = NULL;
 137                                         }
 138                                         break;
 139                                 }
 140                         }
 141
 142                         cs_writeunlock(__func__, &garbage_lock[i]);
 143
 144                         // list has been taken out before so we don't need a lock here anymore!
 145                         while(garbage)
 146                         {
 147                                 next = garbage->next;
 148                                 free(garbage->data);
 149                                 free(garbage);
 150                                 garbage = next;
 151                         }
 152                 }
 153                 sleepms_on_cond(__func__, &sleep_cond_mutex, &sleep_cond, 500);
 154         }
 155         pthread_exit(NULL);
 156 }
 157
 158 void start_garbage_collector(int32_t debug)
 159 {
 160         garbage_debug = debug;
 161         int32_t i;
 162
 163         SAFE_MUTEX_INIT(&add_lock, NULL);
 164
 165         for(i = 0; i < HASH_BUCKETS; ++i)
 166         {
 167                 cs_lock_create(__func__, &garbage_lock[i], "garbage_lock", 9000);
 168
 169                 garbage_first[i] = NULL;
 170         }
 171         cs_pthread_cond_init(__func__, &sleep_cond_mutex, &sleep_cond);
 172
 173         garbage_collector_active = 1;
 174
 175         int32_t ret = start_thread("garbage", (void *)&garbage_collector, NULL, &garbage_thread, 0, 1);
 176         if(ret)
 177         {
 178                 cs_exit(1);
 179         }
 180 }
 181
 182 void stop_garbage_collector(void)
 183 {
 184         if(garbage_collector_active)
 185         {
 186                 int32_t i;
 187
 188                 garbage_collector_active = 0;
 189                 SAFE_COND_SIGNAL(&sleep_cond);
 190                 cs_sleepms(300);
 191                 SAFE_COND_SIGNAL(&sleep_cond);
 192                 SAFE_THREAD_JOIN(garbage_thread, NULL);
 193
 194                 for(i = 0; i < HASH_BUCKETS; ++i)
 195                         { cs_writelock(__func__, &garbage_lock[i]); }
 196
 197                 for(i = 0; i < HASH_BUCKETS; ++i)
 198                 {
 199                         while(garbage_first[i])
 200                         {
 201                                 struct cs_garbage *next = garbage_first[i]->next;
 202                                 NULLFREE(garbage_first[i]->data);
 203                                 NULLFREE(garbage_first[i]);
 204                                 garbage_first[i] = next;
 205                         }
 206                 }
 207
 208                 for(i = 0; i < HASH_BUCKETS; ++i)
 209                 {
 210                         cs_writeunlock(__func__, &garbage_lock[i]);
 211                         cs_lock_destroy(__func__, &garbage_lock[i]);
 212                 }
 213
 214                 pthread_mutex_destroy(&add_lock);
 215                 pthread_cond_destroy(&sleep_cond);
 216                 pthread_mutex_destroy(&sleep_cond_mutex);
 217         }
 218 }