ruby-static-tracing 0.0.12 → 0.0.13

data/ext/ruby-static-tracing/lib/libstapsdt/src/libstapsdt.h

@@ -0,0 +1,67 @@
+#ifndef _LIBSTAPSDT_H
+#define _LIBSTAPSDT_H
+#define MAX_ARGUMENTS 6
+
+typedef enum {
+  noError                 = -1,
+  elfCreationError        = 0,
+  tmpCreationError        = 1,
+  sharedLibraryOpenError  = 2,
+  symbolLoadingError      = 3,
+  sharedLibraryCloseError = 4,
+} SDTError_t;
+
+typedef enum {
+  noarg = 0,
+  uint8 = 1,
+  int8 = -1,
+  uint16 = 2,
+  int16 = -2,
+  uint32 = 4,
+  int32 = -4,
+  uint64 = 8,
+  int64 = -8,
+} ArgType_t;
+
+struct SDTProvider;
+
+typedef struct SDTProbe {
+  char *name;
+  ArgType_t argFmt[MAX_ARGUMENTS];
+  void *_fire;
+  struct SDTProvider *provider;
+  int argCount;
+} SDTProbe_t;
+
+typedef struct SDTProbeList_ {
+  SDTProbe_t probe;
+  struct SDTProbeList_ *next;
+} SDTProbeList_t;
+
+typedef struct SDTProvider {
+  char *name;
+  SDTProbeList_t *probes;
+  SDTError_t errno;
+  char *error;
+
+  // private
+  void *_handle;
+  char *_filename;
+  int _memfd;
+} SDTProvider_t;
+
+SDTProvider_t *providerInit(const char *name);
+
+SDTProbe_t *providerAddProbe(SDTProvider_t *provider, const char *name, int argCount, ...);
+
+int providerLoad(SDTProvider_t *provider);
+
+int providerUnload(SDTProvider_t *provider);
+
+void providerDestroy(SDTProvider_t *provider);
+
+void probeFire(SDTProbe_t *probe, ...);
+
+int probeIsEnabled(SDTProbe_t *probe);
+
+#endif

data/ext/ruby-static-tracing/lib/libstapsdt/src/sdtnote.c

@@ -0,0 +1,176 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "sdtnote.h"
+#include "util.h"
+
+
+// TODO (mmarchini) add other architectures (this only works for x86_64)
+char *regMap(int idx) {
+    switch (idx) {
+      case 0:
+      return "rdi";
+        break;
+      case 1:
+        return "rsi";
+        break;
+      case 2:
+        return "rdx";
+        break;
+      case 3:
+        return "rcx";
+        break;
+      case 4:
+        return "r8";
+        break;
+      case 5:
+        return "r9";
+        break;
+      default:
+        return NULL;
+    }
+}
+
+size_t sdtNoteSize(SDTNote *sdt) {
+  size_t size = 0;
+  size += sizeof(sdt->header);
+  size += sdt->header.n_namesz;
+  size += sdt->header.n_descsz;
+
+  size = roundUp(size, 4);
+
+  return size;
+}
+
+SDTNote *sdtNoteInit(SDTProbe_t *probe) {
+  char buf[100];
+  SDTNote *sdt = calloc(sizeof(SDTNote), 1);
+  size_t descsz = 0, providersz = strlen(probe->provider->name) + 1,
+         probesz = strlen(probe->name) + 1;
+  sdt->header.n_type = NT_STAPSDT;
+  sdt->header.n_namesz = sizeof(NT_STAPSDT_NAME);
+
+  // TODO(matheus): should add pad if sizeof(NT_STAPSDT)%4 != 0
+  sdt->name = calloc(sizeof(NT_STAPSDT_NAME), 1);
+  strncpy(sdt->name, NT_STAPSDT_NAME, strlen(NT_STAPSDT_NAME) + 1);
+
+  sdt->content.probePC = -1;
+  descsz += sizeof(sdt->content.probePC);
+  sdt->content.base_addr = -1;
+  descsz += sizeof(sdt->content.base_addr);
+  sdt->content.sem_addr = 0;
+  descsz += sizeof(sdt->content.sem_addr);
+
+  sdt->content.provider = calloc(providersz, 1);
+  descsz += providersz;
+  strncpy(sdt->content.provider, probe->provider->name, providersz);
+
+  sdt->content.probe = calloc(probesz, 1);
+  descsz += probesz;
+  strncpy(sdt->content.probe, probe->name, probesz);
+
+  sdt->content.argFmt = calloc(sizeof(char), 1);
+  sdt->content.argFmt[0] = '\0';
+  for(int i=0; i < probe->argCount; i++) {
+    sprintf(buf, "%d@%%%s", probe->argFmt[i], regMap(i));
+
+
+    if(i==0) {
+      sdt->content.argFmt = realloc(sdt->content.argFmt, strlen(sdt->content.argFmt) + strlen(buf) + 1);
+      sprintf(sdt->content.argFmt, "%s", buf);
+    } else {
+      sdt->content.argFmt = realloc(sdt->content.argFmt, strlen(sdt->content.argFmt) + strlen(buf) + 2);
+      sprintf(&(sdt->content.argFmt[strlen(sdt->content.argFmt)]), " %s", buf);
+    }
+  }
+  descsz += strlen(sdt->content.argFmt) + 1;
+
+  sdt->header.n_descsz = descsz;
+
+  return sdt;
+}
+
+int sdtNoteToBuffer(SDTNote *sdt, char *buffer) {
+  int cur = 0;
+  size_t sdtSize = sdtNoteSize(sdt);
+
+  // Header
+  memcpy(&(buffer[cur]), &(sdt->header), sizeof(sdt->header));
+  cur += sizeof(sdt->header);
+
+  // Name
+  memcpy(&(buffer[cur]), sdt->name, sdt->header.n_namesz);
+  cur += sdt->header.n_namesz;
+
+  // Content
+  memcpy(&(buffer[cur]), &(sdt->content.probePC), sizeof(sdt->content.probePC));
+  cur += sizeof(sdt->content.probePC);
+
+  memcpy(&(buffer[cur]), &(sdt->content.base_addr),
+         sizeof(sdt->content.base_addr));
+  cur += sizeof(sdt->content.base_addr);
+
+  memcpy(&(buffer[cur]), &(sdt->content.sem_addr),
+         sizeof(sdt->content.sem_addr));
+  cur += sizeof(sdt->content.sem_addr);
+
+  memcpy(&(buffer[cur]), sdt->content.provider,
+         strlen(sdt->content.provider) + 1);
+  cur += strlen(sdt->content.provider) + 1;
+
+  memcpy(&(buffer[cur]), sdt->content.probe, strlen(sdt->content.probe) + 1);
+  cur += strlen(sdt->content.probe) + 1;
+
+  memcpy(&(buffer[cur]), sdt->content.argFmt, strlen(sdt->content.argFmt) + 1);
+  cur += strlen(sdt->content.argFmt) + 1;
+
+  if (cur < sdtSize) {
+    memset(&(buffer[cur]), 0, sdtSize - cur);
+  }
+
+  return sdtSize;
+}
+
+void sdtNoteFree(SDTNote *sdtNote) {
+  free(sdtNote->name);
+  free(sdtNote->content.provider);
+  free(sdtNote->content.probe);
+  free(sdtNote->content.argFmt);
+
+  free(sdtNote);
+}
+
+SDTNoteList_t *sdtNoteListAppend(SDTNoteList_t *list, SDTNote *note) {
+  SDTNoteList_t *newNode = calloc(sizeof(SDTNoteList_t), 1);
+  newNode->next = list;
+  newNode->note = note;
+
+  return newNode;
+}
+
+size_t sdtNoteListSize(SDTNoteList_t *list) {
+  size_t size = 0;
+  for(SDTNoteList_t *node=list; node!=NULL; node=node->next) {
+    size += sdtNoteSize(node->note);
+  }
+
+  return size;
+}
+
+size_t sdtNoteListToBuffer(SDTNoteList_t *list, char *buffer) {
+  size_t offset = 0;
+  for(SDTNoteList_t *node=list; node!=NULL; node=node->next) {
+    offset += sdtNoteToBuffer(node->note, &(buffer[offset]));
+  }
+  return offset;
+}
+
+void sdtNoteListFree(SDTNoteList_t *list) {
+  SDTNoteList_t *node, *next;
+  for(node=list; node!=NULL; node=next) {
+    sdtNoteFree(node->note);
+    next = node->next;
+    free(node);
+  }
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/sdtnote.h

@@ -0,0 +1,46 @@
+#ifndef _SDT_NOTE_H
+#define _SDT_NOTE_H
+
+#include <libelf.h>
+#include "libstapsdt.h"
+
+#define NT_STAPSDT 3
+#define NT_STAPSDT_NAME "stapsdt"
+
+typedef struct SDTNote_ {
+  // Header
+  Elf64_Nhdr header;
+  // Note name
+  char *name;
+  struct {
+    // Note description
+    Elf64_Xword probePC;
+    Elf64_Xword base_addr;
+    Elf64_Xword sem_addr;
+    char *provider; // mainer
+    char *probe;    //
+    char *argFmt;   // \0
+  } content;
+  unsigned long long textSectionOffset;
+} SDTNote;
+
+typedef struct SDTNoteList_ {
+  SDTNote *note;
+  struct SDTNoteList_ *next;
+} SDTNoteList_t;
+
+size_t sdtNoteSize(SDTNote *sdt);
+
+SDTNote *sdtNoteInit(SDTProbe_t *probe);
+
+void sdtNoteFree(SDTNote *sdtNote);
+
+SDTNoteList_t *sdtNoteListAppend(SDTNoteList_t *list, SDTNote *note);
+
+size_t sdtNoteListSize(SDTNoteList_t *list);
+
+size_t sdtNoteListToBuffer(SDTNoteList_t *list, char *buffer);
+
+void sdtNoteListFree(SDTNoteList_t *list);
+
+#endif

data/ext/ruby-static-tracing/lib/libstapsdt/src/section.c

@@ -0,0 +1,30 @@
+#include "section.h"
+
+Section *sectionInit(Elf *e, StringTable *table, char *name) {
+  Section *section = calloc(sizeof(Section), 1);
+
+  section->string = stringTableAdd(table, name);
+
+  if ((section->scn = elf_newscn(e)) == NULL) {
+    free(section);
+    return NULL;
+  }
+
+  if ((section->data = elf_newdata(section->scn)) == NULL) {
+    free(section);
+    return NULL;
+  }
+
+  if ((section->shdr = elf64_getshdr(section->scn)) == NULL) {
+    free(section);
+    return NULL;
+  }
+
+  return section;
+}
+
+
+void sectionFree(Section *section) {
+  // Fields are just references, shouldn't be freed here
+  free(section);
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/section.h

@@ -0,0 +1,21 @@
+#ifndef _SECTION_H
+#define _SECTION_H
+
+#include <libelf.h>
+
+#include "string-table.h"
+
+typedef struct {
+  Elf_Scn *scn;
+  Elf64_Shdr *shdr;
+  Elf_Data *data;
+  Elf64_Addr offset;
+
+  StringTableNode *string;
+} Section;
+
+Section *sectionInit(Elf *e, StringTable *table, char *name);
+
+void sectionFree(Section *section);
+
+#endif

data/ext/ruby-static-tracing/lib/libstapsdt/src/shared-lib.c

@@ -0,0 +1,563 @@
+#include <stdio.h>
+#include "shared-lib.h"
+#include "hash-table.h"
+
+#define PHDR_ALIGN 0x200000
+
+void _funcStart();
+void _funcEnd();
+
+uint32_t eh_frame[] = {0x0, 0x0};
+
+Elf *createElf(int fd) {
+  Elf *e;
+
+  if (elf_version(EV_CURRENT) == EV_NONE) {
+    // TODO (mmarchini) error message
+    return NULL;
+  }
+
+  if ((e = elf_begin(fd, ELF_C_WRITE, NULL)) == NULL) {
+    // TODO (mmarchini) error message
+    return NULL;
+  }
+
+  return e;
+}
+
+ int createElfStringTables(DynElf *dynElf) {
+   // FIXME (mmarchini) error handling
+   dynElf->stringTable = stringTableInit();
+   dynElf->dynamicString = stringTableInit();
+   dynElf->dynamicSymbols = dynamicSymbolTableInit(dynElf->dynamicString);
+   return 0;
+}
+
+Elf64_Ehdr *createElfHeader(Elf *elf) {
+  Elf64_Ehdr *ehdr;
+  if ((ehdr = elf64_newehdr(elf)) == NULL) {
+    // FIXME (mmarchini) properly free everything
+    return NULL;
+  }
+
+  ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
+  ehdr->e_type = ET_DYN;
+  ehdr->e_machine = EM_X86_64;
+  ehdr->e_version = EV_CURRENT;
+  ehdr->e_flags = 0;
+
+  return ehdr;
+}
+
+int createElfProgramHeaders(DynElf *dynElf) {
+  if ((dynElf->phdrLoad1 = elf64_newphdr(dynElf->elf, 4)) == NULL) {
+    // TODO (mmarchini) error message
+    // FIXME (mmarchini) properly free everything
+    return -1;
+  }
+
+  dynElf->phdrDyn = &dynElf->phdrLoad1[2];
+  dynElf->phdrLoad2 = &dynElf->phdrLoad1[1];
+  dynElf->phdrStack = &dynElf->phdrLoad1[3];
+
+  return 0;
+}
+
+int createElfSections(DynElf *dynElf) {
+  // FIXME (mmarchini) error message
+  dynElf->sections.shStrTab = sectionInit(dynElf->elf, dynElf->stringTable, ".shstrtab");
+  dynElf->sections.hash = sectionInit(dynElf->elf, dynElf->stringTable, ".hash");
+  dynElf->sections.dynSym = sectionInit(dynElf->elf, dynElf->stringTable, ".dynsym");
+  dynElf->sections.dynStr = sectionInit(dynElf->elf, dynElf->stringTable, ".dynstr");
+  dynElf->sections.text = sectionInit(dynElf->elf, dynElf->stringTable, ".text");
+  dynElf->sections.ehFrame = sectionInit(dynElf->elf, dynElf->stringTable, ".eh_frame");
+  dynElf->sections.dynamic = sectionInit(dynElf->elf, dynElf->stringTable, ".dynamic");
+  dynElf->sections.sdtBase = sectionInit(dynElf->elf, dynElf->stringTable, ".stapsdt.base");
+  dynElf->sections.sdtNote = sectionInit(dynElf->elf, dynElf->stringTable, ".note.stapsdt");
+
+  return 0;
+}
+
+void *createDynSymData(DynamicSymbolTable *table) {
+  size_t symbolsCount = (5 + table->count);
+  int i;
+  DynamicSymbolList *current;
+  Elf64_Sym *dynsyms = calloc(sizeof(Elf64_Sym), (5 + table->count));
+
+  for (i = 0; i < symbolsCount; i++) {
+    dynsyms[i].st_name = 0;
+    dynsyms[i].st_info = 0;
+    dynsyms[i].st_other = 0;
+    dynsyms[i].st_shndx = 0;
+    dynsyms[i].st_value = 0;
+    dynsyms[i].st_size = 0;
+  }
+
+  dynsyms[1].st_info = ELF64_ST_INFO(STB_LOCAL, STT_SECTION);
+
+  current = table->symbols;
+  for (i = 0; i < table->count; i++) {
+    dynsyms[i + 2].st_name = current->symbol.string->index;
+    dynsyms[i + 2].st_info = ELF64_ST_INFO(STB_GLOBAL, STT_NOTYPE);
+    current = current->next;
+  }
+  i -= 1;
+
+  dynsyms[i + 3].st_name = table->bssStart.string->index;
+  dynsyms[i + 3].st_info = ELF64_ST_INFO(STB_GLOBAL, STT_NOTYPE);
+
+  dynsyms[i + 4].st_name = table->eData.string->index;
+  dynsyms[i + 4].st_info = ELF64_ST_INFO(STB_GLOBAL, STT_NOTYPE);
+
+  dynsyms[i + 5].st_name = table->end.string->index;
+  dynsyms[i + 5].st_info = ELF64_ST_INFO(STB_GLOBAL, STT_NOTYPE);
+
+  return dynsyms;
+}
+
+// TODO(matheus): dynamic strings creation
+void *createDynamicData() {
+  Elf64_Dyn *dyns = calloc(sizeof(Elf64_Dyn), 11);
+
+  for (int i = 0; i < 11; i++) {
+    dyns[i].d_tag = DT_NULL;
+  }
+
+  dyns[0].d_tag = DT_HASH;
+  dyns[1].d_tag = DT_STRTAB;
+  dyns[2].d_tag = DT_SYMTAB;
+  dyns[3].d_tag = DT_STRSZ;
+
+  return dyns;
+}
+
+DynElf *dynElfInit(int fd) {
+  DynElf *dynElf = (DynElf *)calloc(sizeof(DynElf), 1);
+  dynElf->sdtNotes = NULL;
+  dynElf->sdtNotesCount = 0;
+
+  if(createElfStringTables(dynElf) == -1) {
+    // TODO (mmarchini) error message
+    // FIXME (mmarchini) properly free everything
+    free(dynElf);
+    return NULL;
+  }
+
+  dynElf->elf = createElf(fd);
+
+  if ((dynElf->ehdr = createElfHeader(dynElf->elf)) == NULL) {
+    // TODO (mmarchini) error message
+    // FIXME (mmarchini) properly free everything
+    free(dynElf);
+    return NULL;
+  }
+
+  if(createElfProgramHeaders(dynElf) == -1) {
+    // TODO (mmarchini) error message
+    // FIXME (mmarchini) properly free everything
+    free(dynElf);
+    return NULL;
+  }
+
+  if(createElfSections(dynElf) == -1) {
+    // TODO (mmarchini) error message
+    // FIXME (mmarchini) properly free everything
+    free(dynElf);
+    return NULL;
+  }
+
+  return dynElf;
+}
+
+int dynElfAddProbe(DynElf *dynElf, SDTProbe_t *probe) {
+  dynElf->sdtNotes = sdtNoteListAppend(dynElf->sdtNotes, sdtNoteInit(probe));
+  dynamicSymbolTableAdd(dynElf->dynamicSymbols, probe->name);
+  dynElf->sdtNotesCount++;
+
+  return 0;
+}
+
+size_t prepareTextData(DynElf *dynElf, char **textData) {
+  size_t funcSize = (unsigned long long)_funcEnd - (unsigned long long)_funcStart;
+  unsigned long long offset=0;
+  *textData = calloc(funcSize, dynElf->sdtNotesCount);
+
+  for(SDTNoteList_t *node=dynElf->sdtNotes; node!=NULL; node=node->next) {
+    node->note->textSectionOffset = offset;
+    memcpy(&((*textData)[offset]), _funcStart, funcSize);
+    offset += funcSize;
+  }
+
+  return offset;
+}
+
+// TODO (mmarchini) refactor (no idea how)
+int dynElfSave(DynElf *dynElf) {
+  Elf64_Sym *dynSymData = createDynSymData(dynElf->dynamicSymbols);
+  Elf64_Dyn *dynamicData = createDynamicData();
+  void *sdtNoteData = calloc(sdtNoteListSize(dynElf->sdtNotes), 1);
+  void *stringTableData = stringTableToBuffer(dynElf->stringTable),
+       *dynamicStringData = stringTableToBuffer(dynElf->dynamicString);
+  void *textData = NULL;
+  uint32_t *hashTable;
+  size_t hashTableSize = hashTableFromSymbolTable(dynElf->dynamicSymbols, &hashTable);
+  int i;
+
+  // ----------------------------------------------------------------------- //
+  // Section: HASH
+
+  dynElf->sections.hash->data->d_align = 8;
+  dynElf->sections.hash->data->d_off = 0LL;
+  dynElf->sections.hash->data->d_buf = hashTable;
+  dynElf->sections.hash->data->d_type = ELF_T_XWORD;
+  dynElf->sections.hash->data->d_size = hashTableSize;
+  dynElf->sections.hash->data->d_version = EV_CURRENT;
+
+  dynElf->sections.hash->shdr->sh_name = dynElf->sections.hash->string->index;
+  dynElf->sections.hash->shdr->sh_type = SHT_HASH;
+  dynElf->sections.hash->shdr->sh_flags = SHF_ALLOC;
+
+  // ----------------------------------------------------------------------- //
+  // Section: Dynsym
+
+  dynElf->sections.dynSym->data->d_align = 8;
+  dynElf->sections.dynSym->data->d_off = 0LL;
+  dynElf->sections.dynSym->data->d_buf = dynSymData;
+  dynElf->sections.dynSym->data->d_type = ELF_T_XWORD;
+  dynElf->sections.dynSym->data->d_size = sizeof(Elf64_Sym) * ((5 + dynElf->dynamicSymbols->count));
+  dynElf->sections.dynSym->data->d_version = EV_CURRENT;
+
+  dynElf->sections.dynSym->shdr->sh_name = dynElf->sections.dynSym->string->index;
+  dynElf->sections.dynSym->shdr->sh_type = SHT_DYNSYM;
+  dynElf->sections.dynSym->shdr->sh_flags = SHF_ALLOC;
+  dynElf->sections.dynSym->shdr->sh_info = 2; // First non local symbol
+
+  dynElf->sections.hash->shdr->sh_link = elf_ndxscn(dynElf->sections.dynSym->scn);
+
+  // ----------------------------------------------------------------------- //
+  // Section: DYNSTR
+
+  dynElf->sections.dynStr->data->d_align = 1;
+  dynElf->sections.dynStr->data->d_off = 0LL;
+  dynElf->sections.dynStr->data->d_buf = dynamicStringData;
+
+  dynElf->sections.dynStr->data->d_type = ELF_T_BYTE;
+  dynElf->sections.dynStr->data->d_size = dynElf->dynamicString->size;
+  dynElf->sections.dynStr->data->d_version = EV_CURRENT;
+
+  dynElf->sections.dynStr->shdr->sh_name = dynElf->sections.dynStr->string->index;
+  dynElf->sections.dynStr->shdr->sh_type = SHT_STRTAB;
+  dynElf->sections.dynStr->shdr->sh_flags = SHF_ALLOC;
+
+  dynElf->sections.dynSym->shdr->sh_link = elf_ndxscn(dynElf->sections.dynStr->scn);
+
+  // ----------------------------------------------------------------------- //
+  // Section: TEXT
+
+  dynElf->sections.text->data->d_align = 16;
+  dynElf->sections.text->data->d_off = 0LL;
+  dynElf->sections.text->data->d_size = prepareTextData(dynElf, (char **) &textData);
+  dynElf->sections.text->data->d_buf = textData;
+  dynElf->sections.text->data->d_type = ELF_T_BYTE;
+  dynElf->sections.text->data->d_version = EV_CURRENT;
+
+  dynElf->sections.text->shdr->sh_name = dynElf->sections.text->string->index;
+  dynElf->sections.text->shdr->sh_type = SHT_PROGBITS;
+  dynElf->sections.text->shdr->sh_flags = SHF_ALLOC | SHF_EXECINSTR;
+
+  // ----------------------------------------------------------------------- //
+  // Section: SDT BASE
+
+  dynElf->sections.sdtBase->data->d_align = 1;
+  dynElf->sections.sdtBase->data->d_off = 0LL;
+  dynElf->sections.sdtBase->data->d_buf = eh_frame;
+  dynElf->sections.sdtBase->data->d_type = ELF_T_BYTE;
+  dynElf->sections.sdtBase->data->d_size = 1;
+  dynElf->sections.sdtBase->data->d_version = EV_CURRENT;
+
+  dynElf->sections.sdtBase->shdr->sh_name = dynElf->sections.sdtBase->string->index;
+  dynElf->sections.sdtBase->shdr->sh_type = SHT_PROGBITS;
+  dynElf->sections.sdtBase->shdr->sh_flags = SHF_ALLOC;
+
+  // ----------------------------------------------------------------------- //
+  // Section: EH_FRAME
+
+  dynElf->sections.ehFrame->data->d_align = 8;
+  dynElf->sections.ehFrame->data->d_off = 0LL;
+  dynElf->sections.ehFrame->data->d_buf = eh_frame;
+  dynElf->sections.ehFrame->data->d_type = ELF_T_BYTE;
+  dynElf->sections.ehFrame->data->d_size = 0;
+  dynElf->sections.ehFrame->data->d_version = EV_CURRENT;
+
+  dynElf->sections.ehFrame->shdr->sh_name = dynElf->sections.ehFrame->string->index;
+  dynElf->sections.ehFrame->shdr->sh_type = SHT_PROGBITS;
+  dynElf->sections.ehFrame->shdr->sh_flags = SHF_ALLOC;
+
+  // ----------------------------------------------------------------------- //
+  // Section: DYNAMIC
+
+  dynElf->sections.dynamic->data->d_align = 8;
+  dynElf->sections.dynamic->data->d_off = 0LL;
+  dynElf->sections.dynamic->data->d_buf = dynamicData;
+  dynElf->sections.dynamic->data->d_type = ELF_T_BYTE;
+  dynElf->sections.dynamic->data->d_size = 11 * sizeof(Elf64_Dyn);
+  dynElf->sections.dynamic->data->d_version = EV_CURRENT;
+
+  dynElf->sections.dynamic->shdr->sh_name = dynElf->sections.dynamic->string->index;
+  dynElf->sections.dynamic->shdr->sh_type = SHT_DYNAMIC;
+  dynElf->sections.dynamic->shdr->sh_flags = SHF_WRITE | SHF_ALLOC;
+  dynElf->sections.dynamic->shdr->sh_link = elf_ndxscn(dynElf->sections.dynStr->scn);
+
+  // ----------------------------------------------------------------------- //
+  // Section: SDT_NOTE
+
+  dynElf->sections.sdtNote->data->d_align = 4;
+  dynElf->sections.sdtNote->data->d_off = 0LL;
+  dynElf->sections.sdtNote->data->d_buf = sdtNoteData;
+  dynElf->sections.sdtNote->data->d_type = ELF_T_NHDR;
+  dynElf->sections.sdtNote->data->d_size = sdtNoteListSize(dynElf->sdtNotes);
+  dynElf->sections.sdtNote->data->d_version = EV_CURRENT;
+
+  dynElf->sections.sdtNote->shdr->sh_name = dynElf->sections.sdtNote->string->index;
+  dynElf->sections.sdtNote->shdr->sh_type = SHT_NOTE;
+  dynElf->sections.sdtNote->shdr->sh_flags = 0;
+
+  // ----------------------------------------------------------------------- //
+  // Section: SHSTRTAB
+
+  dynElf->sections.shStrTab->data->d_align = 1;
+  dynElf->sections.shStrTab->data->d_off = 0LL;
+  dynElf->sections.shStrTab->data->d_buf = stringTableData;
+  dynElf->sections.shStrTab->data->d_type = ELF_T_BYTE;
+  dynElf->sections.shStrTab->data->d_size = dynElf->stringTable->size;
+  dynElf->sections.shStrTab->data->d_version = EV_CURRENT;
+
+  dynElf->sections.shStrTab->shdr->sh_name = dynElf->sections.shStrTab->string->index;
+  dynElf->sections.shStrTab->shdr->sh_type = SHT_STRTAB;
+  dynElf->sections.shStrTab->shdr->sh_flags = 0;
+
+  dynElf->ehdr->e_shstrndx = elf_ndxscn(dynElf->sections.shStrTab->scn);
+
+  // ----------------------------------------------------------------------- //
+
+  if (elf_update(dynElf->elf, ELF_C_NULL) < 0) {
+    return -1;
+  }
+
+  dynElf->sections.hash->shdr->sh_addr = dynElf->sections.hash->shdr->sh_offset;
+  dynElf->sections.hash->offset = dynElf->sections.hash->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.dynSym->shdr->sh_addr = dynElf->sections.dynSym->shdr->sh_offset;
+  dynElf->sections.dynSym->offset = dynElf->sections.dynSym->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.dynStr->shdr->sh_addr = dynElf->sections.dynStr->shdr->sh_offset;
+  dynElf->sections.dynStr->offset = dynElf->sections.dynStr->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.text->shdr->sh_addr = dynElf->sections.text->shdr->sh_offset;
+  dynElf->ehdr->e_entry = dynElf->sections.text->shdr->sh_addr;
+  dynElf->sections.text->offset = dynElf->sections.text->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.sdtBase->shdr->sh_addr = dynElf->sections.sdtBase->shdr->sh_offset;
+  dynElf->sections.sdtBase->offset = dynElf->sections.sdtBase->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.ehFrame->shdr->sh_addr = dynElf->sections.ehFrame->shdr->sh_offset;
+  dynElf->sections.ehFrame->offset = dynElf->sections.ehFrame->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.dynamic->shdr->sh_addr = PHDR_ALIGN + dynElf->sections.dynamic->shdr->sh_offset;
+  dynElf->sections.dynamic->offset = dynElf->sections.dynamic->shdr->sh_offset;
+
+  // -- //
+
+  dynElf->sections.sdtNote->shdr->sh_addr = dynElf->sections.sdtNote->shdr->sh_offset;
+  dynElf->sections.sdtNote->offset = dynElf->sections.sdtNote->shdr->sh_offset;
+
+  for(SDTNoteList_t *node=dynElf->sdtNotes; node != NULL; node = node->next) {
+    node->note->content.probePC = dynElf->sections.text->offset + node->note->textSectionOffset;
+    node->note->content.base_addr = dynElf->sections.sdtBase->offset;
+  }
+  sdtNoteListToBuffer(dynElf->sdtNotes, sdtNoteData);
+
+  // -- //
+
+  dynElf->sections.shStrTab->offset = dynElf->sections.shStrTab->shdr->sh_offset;
+
+  // -- //
+
+  // ----------------------------------------------------------------------- //
+
+  if (elf_update(dynElf->elf, ELF_C_NULL) < 0) {
+    return -1;
+  }
+
+  // ----------------------------------------------------------------------- //
+  // Fill PHDRs
+
+  // First LOAD PHDR
+
+  dynElf->phdrLoad1->p_type = PT_LOAD;
+  dynElf->phdrLoad1->p_flags = PF_X + PF_R;
+  dynElf->phdrLoad1->p_offset = 0;
+  dynElf->phdrLoad1->p_vaddr = 0;
+  dynElf->phdrLoad1->p_paddr = 0;
+  dynElf->phdrLoad1->p_filesz = dynElf->sections.ehFrame->offset;
+  dynElf->phdrLoad1->p_memsz = dynElf->sections.ehFrame->offset;
+  dynElf->phdrLoad1->p_align = PHDR_ALIGN;
+
+  // Second LOAD PHDR
+
+  dynElf->phdrLoad2->p_type = PT_LOAD;
+  dynElf->phdrLoad2->p_flags = PF_W + PF_R;
+  dynElf->phdrLoad2->p_offset = dynElf->sections.ehFrame->offset;
+  dynElf->phdrLoad2->p_vaddr = dynElf->sections.ehFrame->offset + PHDR_ALIGN;
+  dynElf->phdrLoad2->p_paddr = dynElf->sections.ehFrame->offset + PHDR_ALIGN;
+  dynElf->phdrLoad2->p_filesz = dynElf->sections.dynamic->data->d_size;
+  dynElf->phdrLoad2->p_memsz = dynElf->sections.dynamic->data->d_size;
+  dynElf->phdrLoad2->p_align = PHDR_ALIGN;
+
+  // Dynamic PHDR
+
+  dynElf->phdrDyn->p_type = PT_DYNAMIC;
+  dynElf->phdrDyn->p_flags = PF_W + PF_R;
+  dynElf->phdrDyn->p_offset = dynElf->sections.ehFrame->offset;
+  dynElf->phdrDyn->p_vaddr = dynElf->sections.ehFrame->offset + PHDR_ALIGN;
+  dynElf->phdrDyn->p_paddr = dynElf->sections.ehFrame->offset + PHDR_ALIGN;
+  dynElf->phdrDyn->p_filesz = dynElf->sections.dynamic->data->d_size;
+  dynElf->phdrDyn->p_memsz = dynElf->sections.dynamic->data->d_size;
+  dynElf->phdrDyn->p_align = 0x8; // XXX magic number?
+
+  // GNU_STACK PHDR
+  dynElf->phdrStack->p_type = PT_GNU_STACK;
+  dynElf->phdrStack->p_flags = PF_W + PF_R;
+  dynElf->phdrStack->p_offset = 0;
+  dynElf->phdrStack->p_vaddr = 0;
+  dynElf->phdrStack->p_paddr = 0;
+  dynElf->phdrStack->p_filesz = 0;
+  dynElf->phdrStack->p_memsz = 0;
+  dynElf->phdrStack->p_align = 0x10;
+
+  // Fix offsets DynSym
+  // ----------------------------------------------------------------------- //
+
+  dynSymData[0].st_value = 0;
+
+  dynSymData[1].st_value = dynElf->sections.text->offset;
+  dynSymData[1].st_shndx = elf_ndxscn(dynElf->sections.text->scn);
+
+
+  i=0;
+  for (SDTNoteList_t *node = dynElf->sdtNotes; node != NULL; node = node->next) {
+    dynSymData[i + 2].st_value = dynElf->sections.text->offset + node->note->textSectionOffset;
+    dynSymData[i + 2].st_shndx = elf_ndxscn(dynElf->sections.text->scn);
+    i++;
+  }
+  i -= 1;
+
+  dynSymData[i + 3].st_value = PHDR_ALIGN + dynElf->sections.shStrTab->offset;
+  dynSymData[i + 3].st_shndx = elf_ndxscn(dynElf->sections.dynamic->scn);
+
+  dynSymData[i + 4].st_value = PHDR_ALIGN + dynElf->sections.shStrTab->offset;
+  dynSymData[i + 4].st_shndx = elf_ndxscn(dynElf->sections.dynamic->scn);
+
+  dynSymData[i + 5].st_value = PHDR_ALIGN + dynElf->sections.shStrTab->offset;
+  dynSymData[i + 5].st_shndx = elf_ndxscn(dynElf->sections.dynamic->scn);
+
+  // Fix offsets Dynamic
+  // ----------------------------------------------------------------------- //
+
+  dynamicData[0].d_un.d_ptr = dynElf->sections.hash->offset;
+  dynamicData[1].d_un.d_ptr = dynElf->sections.dynStr->offset;
+  dynamicData[2].d_un.d_ptr = dynElf->sections.dynSym->offset;
+  dynamicData[3].d_un.d_val = dynElf->dynamicString->size;
+  dynamicData[4].d_un.d_val = sizeof(Elf64_Sym);
+
+  // ----------------------------------------------------------------------- //
+
+  elf_flagphdr(dynElf->elf, ELF_C_SET, ELF_F_DIRTY);
+
+  if (elf_update(dynElf->elf, ELF_C_WRITE) < 0) {
+    return -1;
+  }
+
+  free(textData);
+  free(dynSymData);
+  free(dynamicData);
+  free(sdtNoteData);
+  free(stringTableData);
+  free(dynamicStringData);
+  free(hashTable);
+  return 0;
+}
+
+void dynElfSectionsClose(SectionsList *sections) {
+  if(sections->hash != NULL) {
+    sectionFree(sections->hash);
+  }
+
+  if(sections->dynSym != NULL) {
+    sectionFree(sections->dynSym);
+  }
+
+  if(sections->dynStr != NULL) {
+    sectionFree(sections->dynStr);
+  }
+
+  if(sections->text != NULL) {
+    sectionFree(sections->text);
+  }
+
+  if(sections->sdtBase != NULL) {
+    sectionFree(sections->sdtBase);
+  }
+
+  if(sections->ehFrame != NULL) {
+    sectionFree(sections->ehFrame);
+  }
+
+  if(sections->dynamic != NULL) {
+    sectionFree(sections->dynamic);
+  }
+
+  if(sections->sdtNote != NULL) {
+    sectionFree(sections->sdtNote);
+  }
+
+  if(sections->shStrTab != NULL) {
+    sectionFree(sections->shStrTab);
+  }
+}
+
+
+void dynElfClose(DynElf *dynElf) {
+  if(dynElf->stringTable != NULL) {
+    stringTableFree(dynElf->stringTable);
+  }
+
+  if(dynElf->dynamicString != NULL) {
+    stringTableFree(dynElf->dynamicString);
+  }
+
+  if(dynElf->dynamicSymbols != NULL) {
+    dynamicSymbolTableFree(dynElf->dynamicSymbols);
+  }
+
+  if(dynElf->sdtNotes != NULL) {
+    sdtNoteListFree(dynElf->sdtNotes);
+  }
+
+  dynElfSectionsClose(&dynElf->sections);
+
+  (void)elf_end(dynElf->elf);
+  free(dynElf);
+}