modules/informer/src/collector/informer.c

   1 /**
   2         Aesalon, a tool to visualize a program's behaviour at run-time.
   3         Copyright (C) 2010, Aesalon Development Team.
   4
   5         Aesalon is distributed under the terms of the GNU GPLv3. For more
   6         licensing information, see the file LICENSE included with the distribution.
   7
   8         @file modules/informer/src/collector/informer.c
   9
  10 */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <string.h>
  16 #include <fcntl.h>
  17 #include <sys/mman.h>
  18 #include <sys/stat.h>
  19 #include <sys/types.h>
  20 #include <dlfcn.h>
  21 #include <time.h>
  22 #include <pthread.h>
  23 #include <errno.h>
  24
  25 #include "informer/Informer.h"
  26 #include "common/Config.h"
  27 #include "common/ZoneHeader.h"
  28
  29 typedef struct Zone_t Zone_t;
  30 struct Zone_t {
  31         int offset;
  32         Zone_t *next;
  33 };
  34
  35 typedef struct InformerData_t InformerData_t;
  36 struct InformerData_t {
  37         int initialized;
  38         uint64_t processID;
  39
  40         pthread_t monitorThreadList[AesalonInformerMonitorThreadListSize];
  41         int monitorThreadListSize;
  42
  43         pthread_t *threadList;
  44         int threadListSize;
  45         int threadCount;
  46
  47         int shmFd;
  48
  49         SharedMemoryHeader_t *shmHeader;
  50
  51         const char *configData;
  52
  53         uint8_t *zoneUseData;
  54 };
  55
  56 static InformerData_t AI_InformerData;
  57
  58 static __thread uint8_t *AI_Zone = NULL;
  59 static __thread SHMPacketHeader_t *AI_ZonePacket = NULL;
  60
  61 /** Interally-used function; opens shared memory for later use.
  62         @param name The name of the SHM to use.
  63 */
  64 static void AI_OpenSHM(const char *name);
  65
  66 static void AI_SetupHeader();
  67 static void AI_SetupConfig();
  68 static void AI_SetupZoneUse();
  69
  70 static void AI_SetupZone();
  71 static void *AI_ReserveSpace(uint32_t amount);
  72
  73 static int AI_ZoneAvailable(uint32_t id);
  74 static void AI_MarkZone(uint32_t id);
  75 static void AI_ClearZone(uint32_t id);
  76
  77 /** Internally-used function to calculate the amount of space remaining in the zone for
  78         the current thread.
  79         @param zoneID The zone to calculate the remaining space.
  80 */
  81 static uint32_t AI_RemainingSpace();
  82
  83 /* ------------------------------------------------------------------ */
  84
  85 void __attribute__((constructor)) AI_Construct() {
  86         /* By default, .initialized will be set to 0 (AI_InformerData is a global). */
  87         if(AI_InformerData.initialized) return;
  88         AI_InformerData.initialized = 1;
  89
  90         printf("[AI] **** Constructing Informer . . .\n");
  91
  92         pthread_t self = pthread_self();
  93
  94         AI_StopCollection(self);
  95
  96         pid_t pid = getpid();
  97
  98         char filename[1024];
  99
 100         int fd = open("/proc/self/cmdline", O_RDONLY);
 101
 102         read(fd, filename, sizeof(filename));
 103
 104         close(fd);
 105
 106         /* String hashing algorithm: djb2. */
 107
 108         uint64_t pathHash = 0;
 109         int c = 0;
 110         char *p = filename;
 111         while((c = (*p++))) {
 112                 pathHash = c + (pathHash << 6) + (pathHash << 16) - pathHash;
 113         }
 114
 115         /* Clear the first 16 bits for the PID to be inserted properly. */
 116         pathHash &= ~0xffff;
 117
 118         AI_InformerData.processID = pathHash ^ pid;
 119
 120         const char *shmName = getenv("AesalonSHMName");
 121         if(shmName == NULL) {
 122                 fprintf(stderr, "[aesalon] AesalonSHMName not set, aborting.\n");
 123                 exit(1);
 124         }
 125         AI_OpenSHM(shmName);
 126
 127         AI_SetupHeader();
 128         AI_SetupConfig();
 129         AI_SetupZoneUse();
 130
 131         AI_InformerData.threadList = malloc(sizeof(pthread_t) * 16);
 132         AI_InformerData.threadListSize = 16;
 133         AI_InformerData.threadCount = 1;
 134         AI_InformerData.threadList[0] = self;
 135
 136         AI_ContinueCollection(self);
 137
 138         AI_StartPacket(0);
 139         AI_PacketSpace(32);
 140         AI_EndPacket();
 141 }
 142
 143 void __attribute__((destructor)) AI_Destruct() {
 144         printf("[AI] Destructing Informer . . .\n");
 145 }
 146
 147 static void AI_OpenSHM(const char *name) {
 148         AI_InformerData.shmFd = shm_open(name, O_RDWR, S_IRUSR | S_IWUSR);
 149 }
 150
 151 static void AI_SetupHeader() {
 152         AI_InformerData.shmHeader = mmap(NULL, AesalonPageSize,
 153                 PROT_READ | PROT_WRITE, MAP_SHARED, AI_InformerData.shmFd, 0);
 154 }
 155
 156 static void AI_SetupConfig() {
 157         AI_InformerData.configData = mmap(NULL, AI_InformerData.shmHeader->configDataSize*AesalonPageSize,
 158                 PROT_READ | PROT_WRITE, MAP_SHARED, AI_InformerData.shmFd, AesalonPageSize);
 159 }
 160
 161 static void AI_SetupZoneUse() {
 162         AI_InformerData.zoneUseData = mmap(NULL, AI_InformerData.shmHeader->zoneUsagePages*AesalonPageSize,
 163                 PROT_READ | PROT_WRITE, MAP_SHARED, AI_InformerData.shmFd,
 164                 (AI_InformerData.shmHeader->configDataSize + 1)*AesalonPageSize);
 165
 166         /* +1 for the header. */
 167         AI_InformerData.shmHeader->zonePageOffset =
 168                 AI_InformerData.shmHeader->zoneUsagePages + AI_InformerData.shmHeader->configDataSize + 1;
 169 }
 170
 171 static void AI_SetupZone() {
 172         /* Check if more memory is required. */
 173         while(AI_InformerData.shmHeader->zoneCount >= AI_InformerData.shmHeader->zonesAllocated) {
 174                 /* Allocate more memory. */
 175                 sem_wait(&AI_InformerData.shmHeader->resizeSemaphore);
 176                 if(AI_InformerData.shmHeader->zoneCount >= AI_InformerData.shmHeader->zonesAllocated) {
 177                         AI_InformerData.shmHeader->shmSize += AI_InformerData.shmHeader->zoneSize;
 178                         AI_InformerData.shmHeader->zonesAllocated ++;
 179                         ftruncate(AI_InformerData.shmFd, AI_InformerData.shmHeader->shmSize * AesalonPageSize);
 180                 }
 181                 sem_post(&AI_InformerData.shmHeader->resizeSemaphore);
 182         }
 183
 184         uint32_t i;
 185         for(i = 0; i < AI_InformerData.shmHeader->zonesAllocated; i ++) {
 186                 if(AI_ZoneAvailable(i)) break;
 187         }
 188         if(i == AI_InformerData.shmHeader->zonesAllocated) {
 189                 /* Something went pretty seriously wrong. Perhaps another target jumped in and took the spot first? */
 190                 printf("Something very wrong occurred. Trying again . . .\n");
 191                 AI_SetupZone();
 192         }
 193         AI_MarkZone(i);
 194         AI_Zone = mmap(NULL,
 195                 AI_InformerData.shmHeader->zoneSize*AesalonPageSize,
 196                 PROT_READ | PROT_WRITE, MAP_SHARED, AI_InformerData.shmFd,
 197                 (AI_InformerData.shmHeader->zonePageOffset + i*AI_InformerData.shmHeader->zoneSize)*AesalonPageSize);
 198
 199         ((ZoneHeader_t *)AI_Zone)->head = ((ZoneHeader_t *)AI_Zone)->tail = ZoneDataOffset;
 200         ((ZoneHeader_t *)AI_Zone)->overflow = 0;
 201         ((ZoneHeader_t *)AI_Zone)->processID = getpid();
 202         ((ZoneHeader_t *)AI_Zone)->threadID = pthread_self();
 203
 204         sem_init(&((ZoneHeader_t *)AI_Zone)->packetSemaphore, 1, 0);
 205         sem_init(&((ZoneHeader_t *)AI_Zone)->overflowSemaphore, 1, 0);
 206 }
 207
 208 static int AI_ZoneAvailable(uint32_t id) {
 209         uint32_t byteOffset = id / 8;
 210         uint32_t bitOffset = id % 8;
 211         uint32_t mask = 0x01;
 212         return !(AI_InformerData.zoneUseData[byteOffset] & (mask << bitOffset));
 213 }
 214
 215 static void AI_MarkZone(uint32_t id) {
 216         uint32_t byteOffset = id / 8;
 217         uint32_t bitOffset = id % 8;
 218         uint32_t mask = 0x01;
 219         AI_InformerData.zoneUseData[byteOffset] |= (mask << bitOffset);
 220 }
 221
 222 static void AI_ClearZone(uint32_t id) {
 223         uint32_t byteOffset = id / 8;
 224         uint32_t bitOffset = id % 8;
 225         uint32_t mask = 0x01;
 226         AI_InformerData.zoneUseData[byteOffset] &= ~(mask << bitOffset);
 227 }
 228
 229 static uint32_t AI_RemainingSpace() {
 230         ZoneHeader_t *header = (ZoneHeader_t *)AI_Zone;
 231         if(header->head <= header->tail) {
 232                 return ((AI_InformerData.shmHeader->zoneSize*AesalonPageSize) - ZoneDataOffset)
 233                         - (header->tail - header->head);
 234         }
 235         else {
 236                 return header->head - ZoneDataOffset - header->tail;
 237         }
 238 }
 239
 240 static void *AI_ReserveSpace(uint32_t amount) {
 241         uint32_t remaining = AI_RemainingSpace();
 242         ZoneHeader_t *header = (ZoneHeader_t *)AI_Zone;
 243         /*uint32_t zoneDataSize = (AI_InformerData.shmHeader->zoneSize*AesalonPageSize) - ZoneDataOffset;*/
 244         if(remaining < amount) {
 245                 header->overflow = amount - remaining;
 246                 sem_wait(&header->overflowSemaphore);
 247         }
 248
 249         /* If the head is less than (or equal to) the tail, then the used memory
 250                 is in one contiguous chunk, and the buffer has not wrapped yet. */
 251         if(header->tail <= header->head) {
 252 /*              if(header->head + amount >= zoneDataSize) {
 253                         header->gapSize = (amount + header->head) - zoneDataSize;
 254                         amount += header->gapSize;
 255                         header->head = ZoneDataOffset;
 256                 }*/
 257
 258                 header->tail += amount;
 259                 return &AI_Zone[header->tail-amount];
 260         }
 261         else {
 262                 return NULL;
 263         }
 264 }
 265
 266 void AI_StartPacket(ModuleID moduleID) {
 267         if(AI_Zone == NULL) AI_SetupZone();
 268         AI_ZonePacket = AI_ReserveSpace(sizeof(SHMPacketHeader_t));
 269         AI_ZonePacket->packetSize = 0;
 270         AI_ZonePacket->moduleID = moduleID;
 271 }
 272
 273 void AC_EXPORT *AI_PacketSpace(uint32_t size) {
 274         AI_ZonePacket->packetSize += size;
 275         return AI_ReserveSpace(size);
 276 }
 277
 278 void AC_EXPORT AI_EndPacket() {
 279         printf("packet size: %i\n", AI_ZonePacket->packetSize);
 280         AI_ZonePacket = NULL;
 281
 282         ZoneHeader_t *header = (ZoneHeader_t *)AI_Zone;
 283
 284         sem_post(&header->packetSemaphore);
 285
 286         sem_post(&AI_InformerData.shmHeader->packetSemaphore);
 287 }
 288
 289 uint64_t AI_Timestamp() {
 290         struct timespec t;
 291         clock_gettime(CLOCK_REALTIME, &t);
 292         return (t.tv_sec * 1000000000) + t.tv_nsec;
 293 }
 294
 295 const char *AI_ConfigurationString(const char *name) {
 296         uint32_t offset = 0;
 297         while(1) {
 298                 const char *itemName = &AI_InformerData.configData[offset];
 299                 if(itemName == 0 || itemName[0] == 0) break;
 300
 301                 int nameLength = strlen(itemName)+1;
 302                 const char *itemData = &AI_InformerData.configData[offset+nameLength];
 303                 if(!strcmp(name, itemName)) return itemData;
 304
 305                 int dataLength = strlen(itemData)+1;
 306                 offset += nameLength + dataLength;
 307         }
 308         return NULL;
 309 }
 310
 311 long AI_ConfigurationLong(const char *name) {
 312         const char *s = AI_ConfigurationString(name);
 313         if(s == NULL) return -1;
 314         long value;
 315         sscanf(s, "%ld", &value);
 316         return value;
 317 }
 318
 319 int AI_ConfigurationBool(const char *name) {
 320         const char *s = AI_ConfigurationString(name);
 321         if(s == NULL) return 0;
 322         return strcmp(s, "false") != 0;
 323 }
 324
 325 pthread_t *AI_TargetThreadList(int *size) {
 326         if(size == NULL) return NULL;
 327         *size = AI_InformerData.threadCount;
 328
 329         return AI_InformerData.threadList;
 330 }
 331
 332 short AI_CollectionStatus() {
 333         if(AI_InformerData.threadList == NULL) return 0;
 334         pthread_t self = pthread_self();
 335         int i = 0;
 336         while(i < AI_InformerData.monitorThreadListSize) {
 337                 if(pthread_equal(self, AI_InformerData.monitorThreadList[i])) return 0;
 338                 i ++;
 339         }
 340
 341         return 1;
 342 }
 343
 344 void AI_StopCollection(pthread_t tid) {
 345         if(AI_InformerData.monitorThreadListSize < AesalonInformerMonitorThreadListSize) {
 346                 AI_InformerData.monitorThreadList[AI_InformerData.monitorThreadListSize] = tid;
 347                 AI_InformerData.monitorThreadListSize ++;
 348         }
 349         else {
 350                 fprintf(stderr,
 351                         "Too many threads in monitor thread list, output data will be corrupted with Aesalon"
 352                         "collection-thread data.\n");
 353                 fprintf(stderr, "Increasing threadListSize in build/config may be a good idea.\n");
 354         }
 355 }
 356
 357 void AI_ContinueCollection(pthread_t tid) {
 358         int i = 0;
 359         while(i < AI_InformerData.monitorThreadListSize) {
 360                 if(pthread_equal(AI_InformerData.monitorThreadList[i], tid)) {
 361                         AI_InformerData.monitorThreadListSize --;
 362                         AI_InformerData.monitorThreadList[i] =
 363                                 AI_InformerData.monitorThreadList[AI_InformerData.monitorThreadListSize-1];
 364                         break;
 365                 }
 366                 i ++;
 367         }
 368 }
 369