modules/informer/src/collector/Informer.c

   1 /** Aesalon, a tool to visualize program behaviour in real time.
   2         Copyright (C) 2009-2011, Aesalon development team.
   3
   4         Aesalon is distributed under the terms of the GNU GPLv3. See
   5         the included file LICENSE for more information.
   6
   7         @file modules/informer/src/collector/Informer.c
   8 */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <sys/mman.h>
  13 #include <sys/stat.h>
  14 #include <fcntl.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <errno.h>
  18
  19 #include "Config.h"
  20
  21 #include "informer/Informer.h"
  22 #include "shm/PacketHeader.h"
  23 #include "shm/ZoneHeader.h"
  24 #include "util/StringToBool.h"
  25
  26 typedef struct InformerData InformerData;
  27 struct InformerData {
  28         int initialized;
  29         uint64_t processID;
  30
  31         pthread_t monitorThreadList[AesalonInformerMonitorThreadListSize];
  32         int monitorThreadListSize;
  33
  34         pthread_t *threadList;
  35         int threadListSize;
  36         int threadCount;
  37
  38         int shmFd;
  39
  40         SHMHeader *shmHeader;
  41
  42         const char *configData;
  43
  44         uint8_t *zoneUseData;
  45 };
  46
  47 static InformerData AI_InformerData;
  48
  49 static THREAD_SPECIFIC uint8_t *AI_Zone = NULL;
  50 static THREAD_SPECIFIC PacketHeader *AI_ZonePacket = NULL;
  51
  52 static void AI_SetupSHM();
  53 static void *AI_MapSHM(uint32_t start, uint32_t size);
  54 static void *AI_SetupZone();
  55 static void *AI_ReserveSpace(uint32_t size);
  56
  57 void AI_SetupSHM() {
  58         const char *shmName = getenv("AesalonSHMName");
  59         if(shmName == NULL) {
  60                 fprintf(stderr, "AesalonSHMName not set, aborting . . .\n");
  61                 exit(1);
  62         }
  63
  64         AI_InformerData.shmFd = shm_open(shmName, O_RDWR, S_IRUSR | S_IWUSR);
  65
  66         AI_InformerData.shmHeader = AI_MapSHM(0, 1);
  67         AI_InformerData.configData = AI_MapSHM(1, AI_InformerData.shmHeader->configDataSize);
  68         AI_InformerData.zoneUseData =
  69                 AI_MapSHM(AI_InformerData.shmHeader->configDataSize+1, AI_InformerData.shmHeader->zoneUsagePages);
  70 }
  71
  72 void *AI_MapSHM(uint32_t start, uint32_t size) {
  73         if(AI_InformerData.shmHeader != NULL && AI_InformerData.shmHeader->shmSize < (start+size)) {
  74                 sem_wait(&AI_InformerData.shmHeader->resizeSemaphore);
  75
  76                 if(ftruncate(AI_InformerData.shmFd, (start+size) * AesalonPageSize) != 0) {
  77                         fprintf(stderr, "Could not resize shared memory.");
  78                         exit(1);
  79                 }
  80
  81                 sem_post(&AI_InformerData.shmHeader->resizeSemaphore);
  82         }
  83
  84         void *memory =
  85                 mmap(NULL, size * AesalonPageSize, PROT_READ | PROT_WRITE,
  86                         MAP_SHARED, AI_InformerData.shmFd, start * AesalonPageSize);
  87
  88         return memory;
  89 }
  90
  91 static void *AI_SetupZone() {
  92         /* While more memory is required . . . */
  93         while(AI_InformerData.shmHeader->zoneCount >= AI_InformerData.shmHeader->zonesAllocated) {
  94                 /* Allocate more memory. */
  95                 sem_wait(&AI_InformerData.shmHeader->resizeSemaphore);
  96
  97                 /* This seemingly-nonsensical statement is to account for the fact that during the wait above,
  98                         another thread may have jumped in and allocated a zone.
  99                 */
 100                 if(AI_InformerData.shmHeader->zoneCount >= AI_InformerData.shmHeader->zonesAllocated) {
 101                         /* Allocate two zones per iteration. */
 102                         AI_InformerData.shmHeader->shmSize += AI_InformerData.shmHeader->zoneSize * 2;
 103                         AI_InformerData.shmHeader->zonesAllocated += 2;
 104
 105                         ftruncate(AI_InformerData.shmFd, AI_InformerData.shmHeader->shmSize * AesalonPageSize);
 106                 }
 107
 108                 sem_post(&AI_InformerData.shmHeader->resizeSemaphore);
 109         }
 110
 111         uint32_t i;
 112         for(i = 0; i < AI_InformerData.shmHeader->zonesAllocated; i ++) {
 113                 if(AI_InformerData.zoneUseData[i/8] & (0x01 << (i % 8))) break;
 114         }
 115         if(i == AI_InformerData.shmHeader->zonesAllocated) {
 116                 /* Something went pretty seriously wrong. Perhaps another target jumped in and took the spot first? */
 117                 printf("Something very wrong occurred. Trying again . . .\n");
 118                 /* Just temporarily use recursion to fix the problem. Note: don't try this at home . . . */
 119                 AI_SetupZone();
 120         }
 121         AI_InformerData.zoneUseData[i/8] |= (0x01 << (i%8));
 122
 123         AI_Zone = AI_MapSHM(
 124                 AI_InformerData.shmHeader->zonePageOffset + (i*AI_InformerData.shmHeader->zoneSize),
 125                 AI_InformerData.shmHeader->zoneSize);
 126
 127         ((ZoneHeader *)AI_Zone)->head = ((ZoneHeader *)AI_Zone)->tail = ZoneDataOffset;
 128         ((ZoneHeader *)AI_Zone)->overflow = 0;
 129         /* TODO: implement support for finding the process ID. */
 130         ((ZoneHeader *)AI_Zone)->processID = 0;
 131         ((ZoneHeader *)AI_Zone)->threadID = ++AI_InformerData.shmHeader->lastThreadID;
 132
 133         return AI_Zone;
 134 }
 135
 136 static void *AI_ReserveSpace(uint32_t size) {
 137         ZoneHeader *header = (ZoneHeader *)AI_Zone;
 138         uint32_t remaining;
 139         if(header->head <= header->tail) {
 140                 remaining = ((AI_InformerData.shmHeader->zoneSize*AesalonPageSize) - ZoneDataOffset)
 141                         - (header->tail - header->head);
 142         }
 143         else {
 144                 remaining = header->head - ZoneDataOffset - header->tail;
 145         }
 146
 147         if(remaining < size) {
 148                 header->overflow = size - remaining;
 149                 sem_wait(&header->overflowSemaphore);
 150         }
 151
 152         /* If the head is less than (or equal to) the tail, then the used memory
 153                 is in one contiguous chunk, and the buffer has not wrapped yet. */
 154         if(header->head <= header->tail) {
 155                 header->tail += size;
 156                 return &AI_Zone[header->tail-size];
 157         }
 158         else {
 159                 printf("**** Second case, returning NULL.\n");
 160                 return NULL;
 161         }
 162 }
 163
 164 void __attribute__((constructor)) AI_Construct() {
 165         if(AI_InformerData.initialized == 1) return;
 166         pthread_t self = pthread_self();
 167         AI_StopCollection(self);
 168         AI_InformerData.initialized = 1;
 169
 170         AI_SetupSHM();
 171
 172         AI_InformerData.threadList = malloc(sizeof(pthread_t) * 16);
 173         AI_InformerData.threadListSize = 16;
 174         AI_InformerData.threadCount = 1;
 175         AI_InformerData.threadList[0] = self;
 176
 177         AI_ContinueCollection(self);
 178 }
 179
 180 void __attribute__((destructor)) AI_Destruct() {
 181
 182 }
 183
 184 void AC_EXPORT AI_StartPacket(ModuleID moduleID) {
 185         if(AI_Zone == NULL) AI_SetupZone();
 186         AI_ZonePacket = AI_ReserveSpace(sizeof(PacketHeader));
 187         AI_ZonePacket->packetSize = 0;
 188         AI_ZonePacket->moduleID = moduleID;
 189
 190 }
 191
 192 void AC_EXPORT *AI_PacketSpace(uint32_t size) {
 193         AI_ZonePacket->packetSize += size;
 194         return AI_ReserveSpace(size);
 195 }
 196
 197 void AC_EXPORT AI_EndPacket() {
 198
 199 }
 200
 201 const char *AI_ConfigurationString(const char *name) {
 202         uint32_t offset = 0;
 203         while(1) {
 204                 const char *itemName = &AI_InformerData.configData[offset];
 205                 if(itemName == 0 || itemName[0] == 0) break;
 206
 207                 int nameLength = strlen(itemName)+1;
 208                 const char *itemData = &AI_InformerData.configData[offset+nameLength];
 209                 if(!strcmp(name, itemName)) return itemData;
 210
 211                 int dataLength = strlen(itemData)+1;
 212                 offset += nameLength + dataLength;
 213         }
 214         return NULL;
 215 }
 216
 217 long AI_ConfigurationLong(const char *name) {
 218         const char *s = AI_ConfigurationString(name);
 219         if(s == NULL) return -1;
 220         long value;
 221         sscanf(s, "%ld", &value);
 222         return value;
 223 }
 224
 225 int AI_ConfigurationBool(const char *name) {
 226         const char *s = AI_ConfigurationString(name);
 227         if(s == NULL) return 0;
 228         return StringToBool(s);
 229 }
 230
 231 void AI_StopCollection(pthread_t threadID) {
 232         if(AI_InformerData.monitorThreadListSize < AesalonInformerMonitorThreadListSize) {
 233                 AI_InformerData.monitorThreadList[AI_InformerData.monitorThreadListSize] = threadID;
 234                 AI_InformerData.monitorThreadListSize ++;
 235         }
 236         else {
 237                 fprintf(stderr,
 238                         "Too many threads in monitor thread list, output data will be corrupted with Aesalon"
 239                         "collection-thread data.\n");
 240                 fprintf(stderr, "Increasing threadListSize in build/config may be a good idea.\n");
 241         }
 242 }
 243
 244 void AI_ContinueCollection(pthread_t threadID) {
 245         int i = 0;
 246         while(i < AI_InformerData.monitorThreadListSize) {
 247                 if(pthread_equal(AI_InformerData.monitorThreadList[i], threadID)) {
 248                         AI_InformerData.monitorThreadListSize --;
 249                         AI_InformerData.monitorThreadList[i] =
 250                                 AI_InformerData.monitorThreadList[AI_InformerData.monitorThreadListSize-1];
 251                         break;
 252                 }
 253                 i ++;
 254         }
 255 }
 256
 257 short AI_CollectionStatus() {
 258         if(AI_InformerData.initialized == 0) return 0;
 259         pthread_t self = pthread_self();
 260         int i = 0;
 261         while(i < AI_InformerData.monitorThreadListSize) {
 262                 if(pthread_equal(self, AI_InformerData.monitorThreadList[i])) return 0;
 263                 i ++;
 264         }
 265
 266         return 1;
 267 }