latest version of key-value-store (updated database structure, using mmap for database access, added recovery mechanism)

8 files changed, 2965 insertions, 1823 deletions

diff --git a/src/key-value-store/crc32.c b/src/key-value-store/crc32.c
index caa58e4..55c9d08 100644
--- a/src/key-value-store/crc32.c
+++ b/src/key-value-store/crc32.c
@@ -118,53 +118,16 @@ unsigned int pcoCrc32(unsigned int crc, const unsigned char *buf, size_t theSize
    p = buf;
    crc = crc ^ ~0U;
 
-   if(p != 0)
+   if (p != 0)
    {
-      while(theSize--)
+      while (theSize--)
       {
-	     unsigned int idx = (crc ^ *p++) & 0xFF;
+         unsigned int idx = (crc ^ *p++) & 0xFF;
 
-	     if(idx < crc32_array_size)
-		     crc = crc32_tab[idx] ^ (crc >> 8);
+         if (idx < crc32_array_size)
+            crc = crc32_tab[idx] ^ (crc >> 8);
       }
       rval = crc ^ ~0U;
    }
    return rval;
 }
-
-
-int pcoCalcCrc32Csum(int fd, int startOffset)
-{
-   int rval = 1;
-   char* buf;
-   struct stat statBuf;
-   unsigned int crc = 0;
-
-   fstat(fd, &statBuf);
-   buf = malloc((unsigned int) statBuf.st_size- startOffset);
-
-   if (buf != 0)
-   {
-      memset(buf, 0, statBuf.st_size- startOffset);
-      off_t curPos = 0;
-      // remember the current position
-      curPos = lseek(fd, 0, SEEK_CUR);
-      // set to start offset
-      lseek(fd, startOffset, SEEK_SET);
-      //printf("FSTAT -> Filesize: %d \n", (int) statBuf.st_size);
-      if( read(fd, buf, statBuf.st_size- startOffset) != statBuf.st_size- startOffset)
-         return -1;
-      crc = 0;
-      crc = pcoCrc32(crc, (unsigned char*) buf, statBuf.st_size- startOffset);
-      rval = crc;
-      // set back to the position
-      lseek(fd, curPos, SEEK_SET);
-      free(buf);
-   }
-   else
-      rval = -1;
-   return rval;
-}
-
-
-
diff --git a/src/key-value-store/database/kissdb.c b/src/key-value-store/database/kissdb.c
index 4c8e7b6..6a4d119 100644
--- a/src/key-value-store/database/kissdb.c
+++ b/src/key-value-store/database/kissdb.c
@@ -1,8 +1,8 @@
- /******************************************************************************
- * Project         Persistency
- * (c) copyright   2014
- * Company         XS Embedded GmbH
- *****************************************************************************/
+/******************************************************************************
+* Project         Persistency
+* (c) copyright   2014
+* Company         XS Embedded GmbH
+*****************************************************************************/
 /* (Keep It) Simple Stupid Database
 *
 * Written by Adam Ierymenko <adam.ierymenko@zerotier.com>
@@ -17,14 +17,8 @@
 /* Note: big-endian systems will need changes to implement byte swapping
 * on hash table file I/O. Or you could just use it as-is if you don't care
 * that your database files will be unreadable on little-endian systems. */
-
 #define _FILE_OFFSET_BITS 64
-#define TMP_BUFFER_LENGTH 128
 #define KISSDB_HEADER_SIZE sizeof(Header_s)
-#define __useBackups
-//#define __useFileMapping
-//#define __writeThrough
-#define __checkerror
 
 #include "./kissdb.h"
 #include "../crc32.h"
@@ -37,11 +31,20 @@
 #include <sys/mman.h>
 #include <unistd.h>
 #include <ctype.h>
+#include <sys/stat.h>
 #include <sys/time.h>
+#include <semaphore.h>
+#include <dlt.h>
+#include "persComErrors.h"
 
-#include "dlt.h"
+//
+//#ifdef COND_GCOV
+//extern void __gcov_flush(void);
+//#endif
 
-DLT_DECLARE_CONTEXT(persComLldbDLTCtx);
+//#define PFS_TEST
+//extern DltContext persComLldbDLTCtx;
+DLT_IMPORT_CONTEXT (persComLldbDLTCtx)
 
 #ifdef __showTimeMeasurements
 inline long long getNsDuration(struct timespec* start, struct timespec* end)
@@ -51,43 +54,59 @@ inline long long getNsDuration(struct timespec* start, struct timespec* end)
 #endif
 
 /* djb2 hash function */
-static uint64_t KISSDB_hash(const void *b, unsigned long len)
+static uint64_t KISSDB_hash(const void* b, unsigned long len)
 {
    unsigned long i;
    uint64_t hash = 5381;
    for (i = 0; i < len; ++i)
-      hash = ((hash << 5) + hash) + (uint64_t) (((const uint8_t *) b)[i]);
+   {
+      hash = ((hash << 5) + hash) + (uint64_t) (((const uint8_t*) b)[i]);
+   }
    return hash;
 }
 
+#if 1
 //returns a name for shared memory objects beginning with a slash followed by "path" (non alphanumeric chars are replaced with '_')  appended with "tailing"
-char * kdbGetShmName(const char *tailing, const char * path)
+char* kdbGetShmName(const char* tailing, const char* path)
 {
-   char * result = (char *) malloc(1 +  strlen(path) + strlen(tailing) + 1); //free happens at lifecycle shutdown
+   int pathLen = strlen(path);
+   int tailLen = strlen(tailing);
+   char* result = (char*) malloc(1 + pathLen + tailLen + 1);   //free happens at lifecycle shutdown
    int i =0;
    int x = 1;
 
    if (result != NULL)
    {
       result[0] = '/';
-      for (i = 0; i < strlen(path); i++)
+      for (i = 0; i < pathLen; i++)
       {
          if (!isalnum(path[i]))
+         {
             result[i + 1] = '_';
+         }
          else
+         {
             result[i + 1] = path[i];
+         }
       }
-      for (x = 0; x < strlen(tailing); x++)
+      for (x = 0; x < tailLen; x++)
       {
          result[i + x + 1] = tailing[x];
       }
       result[i + x + 1] = '\0';
    }
+   else
+   {
+      result = NULL;
+   }
    return result;
 }
+#endif
+
+
 
 //returns -1 on error and positive value for success
-int kdbShmemOpen(const char * name, size_t length, Kdb_bool* shmCreator)
+int kdbShmemOpen(const char* name, size_t length, Kdb_bool* shmCreator)
 {
    int result;
    result = shm_open(name, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
@@ -98,111 +117,268 @@ int kdbShmemOpen(const char * name, size_t length, Kdb_bool* shmCreator)
          *shmCreator = Kdb_false;
          result = shm_open(name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
          if (result < 0)
+         {
             return -1;
+         }
       }
    }
    else
    {
       *shmCreator = Kdb_true;
       if (ftruncate(result, length) < 0)
+      {
          return -1;
+      }
    }
    return result;
 }
 
-void Kdb_wrlock(pthread_rwlock_t * wrlock)
+void Kdb_wrlock(pthread_rwlock_t* wrlock)
 {
    pthread_rwlock_wrlock(wrlock);
 }
 
-void Kdb_rdlock(pthread_rwlock_t * rdlock)
-{
-   pthread_rwlock_rdlock(rdlock);
-}
+//void Kdb_rdlock(pthread_rwlock_t* rdlock)
+//{
+//   pthread_rwlock_rdlock(rdlock);
+//}
 
-void Kdb_unlock(pthread_rwlock_t * lock)
+void Kdb_unlock(pthread_rwlock_t* lock)
 {
    pthread_rwlock_unlock(lock);
 }
 
-Kdb_bool kdbShmemClose(int shmem, const char * shmName)
+Kdb_bool kdbShmemClose(int shmem, const char* shmName)
 {
    if( close(shmem) == -1)
+   {
       return Kdb_false;
+   }
    if( shm_unlink(shmName) < 0)
+   {
       return Kdb_false;
+   }
    return Kdb_true;
 }
 
-void * getKdbShmemPtr(int shmem, size_t length)
+void* getKdbShmemPtr(int shmem, size_t length)
 {
    void* result = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, shmem, 0);
    if (result == MAP_FAILED)
-      return ((void *) -1);
+   {
+      return ((void*) -1);
+   }
    return result;
 }
 
-Kdb_bool freeKdbShmemPtr(void * shmem_ptr, size_t length)
+
+Kdb_bool freeKdbShmemPtr(void* shmem_ptr, size_t length)
 {
    if(munmap(shmem_ptr, length) == 0)
+   {
       return Kdb_true;
+   }
    else
+   {
       return Kdb_false;
+   }
 }
 
-Kdb_bool resizeKdbShmem(int shmem, Hashtable_slot_s** shmem_ptr, size_t oldLength, size_t newLength)
+Kdb_bool resizeKdbShmem(int shmem, Hashtable_s** shmem_ptr, size_t oldLength, size_t newLength)
 {
    //unmap shm with old size
    if( freeKdbShmemPtr(*shmem_ptr, oldLength) == Kdb_false)
+   {
       return Kdb_false;
+   }
 
    if (ftruncate(shmem, newLength) < 0)
+   {
       return Kdb_false;
+   }
 
    //get pointer to resized shm with new Length
    *shmem_ptr = getKdbShmemPtr(shmem, newLength);
-   if(*shmem_ptr == ((void *) -1))
+   if(*shmem_ptr == ((void*) -1))
+   {
       return Kdb_false;
+   }
    return Kdb_true;
 }
 
-#ifdef __writeThrough
-Kdb_bool remapKdbShmem(int shmem, uint64_t** shmem_ptr, size_t oldLength, size_t newLength)
+
+Kdb_bool remapSharedHashtable(int shmem, Hashtable_s** shmem_ptr, size_t oldLength, size_t newLength )
 {
-   //unmap shm with old size
-   if( freeKdbShmemPtr(*shmem_ptr, oldLength) == Kdb_false )
+   //unmap hashtable with old size
+   if( freeKdbShmemPtr(*shmem_ptr, oldLength) == Kdb_false)
+   {
       return Kdb_false;
+   }
    //get pointer to resized shm with new Length
    *shmem_ptr = getKdbShmemPtr(shmem, newLength);
-   if(*shmem_ptr == ((void *) -1))
+   if(*shmem_ptr == ((void*) -1))
+   {
       return Kdb_false;
+   }
    return Kdb_true;
 }
+
+#if 0
+void printKdb(KISSDB* db)
+{
+   printf("START ############################### \n");
+   printf("db->htSize:  %d \n", db->htSize);
+   printf("db->cacheReferenced: %d \n", db->cacheReferenced);
+   printf("db->keySize:  %" PRId64 " \n", db->keySize);
+   printf("db->valSize:  %" PRId64 " \n", db->valSize);
+   printf("db->htSizeBytes:  %" PRId64 " \n", db->htSizeBytes);
+   printf("db->htMappedSize:  %" PRId64 " \n", db->htMappedSize);
+   printf("db->dbMappedSize:  %" PRId64 " \n", db->dbMappedSize);
+   printf("db->shmCreator:  %d \n", db->shmCreator);
+   printf("db->alreadyOpen:  %d \n", db->alreadyOpen);
+   printf("db->hashTables:  %p \n", db->hashTables);
+   printf("db->mappedDb:  %p \n", db->mappedDb);
+   printf("db->sharedCache:  %p \n", db->sharedCache);
+   printf("db->sharedFd:  %d \n", db->sharedFd);
+   printf("db->htFd:  %d \n", db->htFd);
+   printf("db->sharedCacheFd:  %d \n", db->sharedCacheFd);
+   printf("db->semName:  %s \n", db->semName);
+   printf("db->sharedName:  %s \n", db->sharedName);
+   printf("db->cacheName:  %s \n", db->cacheName);
+   printf("db->htName:  %s \n", db->htName);
+   printf("db->shared:  %p \n", db->shared);
+   printf("db->tbl:  %p \n", db->tbl[0]);
+   printf("db->kdbSem:  %p \n", db->kdbSem);
+   printf("db->fd:  %d \n", db->fd);
+   printf("END ############################### \n");
+}
 #endif
 
 
-int KISSDB_open(KISSDB *db, const char *path, int mode, uint16_t hash_table_size, uint64_t key_size,
-      uint64_t value_size)
+int KISSDB_open(KISSDB* db, const char* path, int openMode, int writeMode, uint16_t hash_table_size, uint64_t key_size, uint64_t value_size)
 {
-   Hashtable_slot_s *httmp;
-   Kdb_bool tmp_creator;
+   Hashtable_s* htptr;
    int ret = 0;
+   Kdb_bool htFound;
+   Kdb_bool tmpCreator;
+   off_t offset = 0;
+   size_t firstMappSize;
+   struct stat sb;
 
-   //TODO check if usage of O_SYNC O_DIRECT flags is needed. If O_SYNC and O_DIrect is specified, no additional fsync calls are needed after fflush
-   if(mode == KISSDB_OPEN_MODE_RWCREAT)
-      db->fd = open(path, O_CREAT | O_RDWR , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH  ); //gets closed when db->f is closed
+   if (db->alreadyOpen == Kdb_false) //check if this instance has already opened the db before
+   {
+      db->sharedName = kdbGetShmName("-shm-info", path);
+      if (db->sharedName == NULL)
+      {
+         return KISSDB_ERROR_MALLOC;
+      }
+      db->sharedFd = kdbShmemOpen(db->sharedName, sizeof(Shared_Data_s), &db->shmCreator);
+      if (db->sharedFd < 0)
+      {
+         return KISSDB_ERROR_OPEN_SHM;
+      }
+      db->shared = (Shared_Data_s*) getKdbShmemPtr(db->sharedFd, sizeof(Shared_Data_s));
+      if (db->shared == ((void*) -1))
+      {
+         return KISSDB_ERROR_MAP_SHM;
+      }
+
+      db->sharedCacheFd = -1;
+      db->mappedDb = NULL;
+
+      if (db->shmCreator == Kdb_true)
+      {
+         //[Initialize rwlock attributes]
+         pthread_rwlockattr_t rwlattr;
+         pthread_rwlockattr_init(&rwlattr);
+         pthread_rwlockattr_setpshared(&rwlattr, PTHREAD_PROCESS_SHARED);
+         pthread_rwlock_init(&db->shared->rwlock, &rwlattr);
+
+         Kdb_wrlock(&db->shared->rwlock);
+
+         //init cache filedescriptor, reference counter and hashtable number
+         db->sharedCacheFd = -1;
+         db->shared->refCount = 0;
+         db->shared->htNum = 0;
+         db->shared->mappedDbSize = 0;
+         db->shared->writeMode = writeMode;
+         db->shared->openMode = openMode;
+      }
+      else
+      {
+         Kdb_wrlock(&db->shared->rwlock);
+      }
+   }
    else
-      db->fd = open(path, O_RDWR , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH  ); //gets closed when db->f is closed
+   {
+      Kdb_wrlock(&db->shared->rwlock);
+   }
 
+   switch (db->shared->openMode)
+   {
+      case KISSDB_OPEN_MODE_RWCREAT:
+      {
+         //create database
+         db->fd = open(path, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+         break;
+      }
+      case KISSDB_OPEN_MODE_RDWR:
+      {
+         //read / write mode
+         db->fd = open(path, O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+         break;
+      }
+      case KISSDB_OPEN_MODE_RDONLY:
+      {
+         db->fd = open(path, O_RDONLY);
+         break;
+      }
+      default:
+      {
+         break;
+      }
+   }
    if(db->fd == -1)
+   {
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": Opening database file: <"); DLT_STRING(path); DLT_STRING("> failed: "); DLT_STRING(strerror(errno)));
       return KISSDB_ERROR_IO;
+   }
 
-   if (lseek(db->fd, 0, SEEK_END) == -1)
+   if( 0 != fstat(db->fd, &sb))
    {
-      close(db->fd);
       return KISSDB_ERROR_IO;
    }
-   if (lseek(db->fd, 0, SEEK_CUR) < KISSDB_HEADER_SIZE)
+
+
+   /* mmap whole database file if it already exists (else the file is mapped in writeheader()) */
+   if (sb.st_size > 0)
+   {
+      if(db->shared->openMode != KISSDB_OPEN_MODE_RDONLY )
+      {
+         db->mappedDb = (void*) mmap(NULL, sb.st_size, PROT_WRITE | PROT_READ, MAP_SHARED, db->fd, 0);
+      }
+      else
+      {
+         db->mappedDb = (void*) mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, db->fd, 0);
+      }
+      if (db->mappedDb == MAP_FAILED)
+      {
+         return KISSDB_ERROR_IO;
+      }
+      else
+      {
+         //update mapped size
+         db->shared->mappedDbSize = (uint64_t)sb.st_size;
+         db->dbMappedSize = db->shared->mappedDbSize;
+      }
+   }
+
+   offset = sb.st_size;
+   if (offset == -1)
+   {
+      return KISSDB_ERROR_IO;
+   }
+   if ( offset < KISSDB_HEADER_SIZE)
    {
       /* write header if not already present */
       if ((hash_table_size) && (key_size) && (value_size))
@@ -210,1029 +386,891 @@ int KISSDB_open(KISSDB *db, const char *path, int mode, uint16_t hash_table_size
          ret = writeHeader(db, &hash_table_size, &key_size, &value_size);
          if(0 != ret)
          {
-            close(db->fd);
             return ret;
          }
-         //Seek behind header
-         if (lseek(db->fd, KISSDB_HEADER_SIZE, SEEK_SET) == -1)
-         {
-            close(db->fd);
-            return KISSDB_ERROR_IO;
-         }
       }
       else
       {
-         close(db->fd);
          return KISSDB_ERROR_INVALID_PARAMETERS;
       }
    }
    else
    {
-      //read existing header
+      /* read existing header to verify database version */
       ret = readHeader(db, &hash_table_size, &key_size, &value_size);
       if( 0 != ret)
-         return ret;
-
-      if (lseek(db->fd, KISSDB_HEADER_SIZE, SEEK_SET) == -1)
       {
-         close(db->fd);
-         return KISSDB_ERROR_IO;
-      } //Seek behind header
+         return ret;
+      }
    }
    //store non shared db information
-   db->hash_table_size = hash_table_size;
-   db->key_size = key_size;
-   db->value_size = value_size;
-   db->hash_table_size_bytes = sizeof(Hashtable_slot_s) * (hash_table_size + 1); /* [hash_table_size] == next table */
+   db->htSize = hash_table_size;
+   db->keySize = key_size;
+   db->valSize = value_size;
+   db->htSizeBytes = sizeof(Hashtable_s);
 
-   //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("Hashtable size in bytes: "), DLT_UINT64(db->hash_table_size_bytes));
-
-   if (db->already_open == Kdb_false) //check if this instance has already opened the db before
+   if (db->alreadyOpen == Kdb_false) //check if this instance has already opened the db before
    {
-      db->shmem_cached_name = kdbGetShmName("-cache", path);
-      if(db->shmem_cached_name == NULL)
-         return KISSDB_ERROR_MALLOC;
-      db->shmem_info_name = kdbGetShmName("-shm-info", path);
-      if(db->shmem_info_name == NULL)
+      db->cacheName = kdbGetShmName("-cache", path);
+      if(db->cacheName == NULL)
+      {
          return KISSDB_ERROR_MALLOC;
-      db->shmem_info_fd = kdbShmemOpen(db->shmem_info_name, sizeof(Shared_Data_s), &db->shmem_creator);
-      if(db->shmem_info_fd < 0)
-         return KISSDB_ERROR_OPEN_SHM;
-      db->shmem_info = (Shared_Data_s *) getKdbShmemPtr(db->shmem_info_fd, sizeof(Shared_Data_s));
-      if(db->shmem_info == ((void *) -1))
-         return KISSDB_ERROR_MAP_SHM;
-
-      size_t first_mapping;
-      if(db->shmem_info->shmem_size > db->hash_table_size_bytes )
-         first_mapping = db->shmem_info->shmem_size;
+      }
+      //check if more than one hashtable is already in shared memory
+      if(db->shared->htShmSize > db->htSizeBytes )
+      {
+         firstMappSize = db->shared->htShmSize;
+      }
       else
-         first_mapping = db->hash_table_size_bytes;
+      {
+         firstMappSize = db->htSizeBytes;
+      }
 
       //open / create shared memory for first hashtable
-      db->shmem_ht_name = kdbGetShmName("-ht", path);
-      if(db->shmem_ht_name == NULL)
+      db->htName = kdbGetShmName("-ht", path);
+      if(db->htName == NULL)
+      {
          return KISSDB_ERROR_MALLOC;
-      db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name,  first_mapping, &tmp_creator);
-      if(db->shmem_ht_fd < 0)
+      }
+      db->htFd = kdbShmemOpen(db->htName,  firstMappSize, &tmpCreator);
+      if(db->htFd < 0)
+      {
          return KISSDB_ERROR_OPEN_SHM;
-      db->hash_tables = (Hashtable_slot_s *) getKdbShmemPtr(db->shmem_ht_fd, first_mapping);
-      if(db->hash_tables == ((void *) -1))
-         return KISSDB_ERROR_MAP_SHM;
-      db->old_mapped_size = first_mapping; //local information
-
-      //if shared memory for rwlock was opened (created) with this call to KISSDB_open for the first time -> init rwlock
-      if (db->shmem_creator == Kdb_true)
+      }
+      db->hashTables = (Hashtable_s*) getKdbShmemPtr(db->htFd, firstMappSize);
+      if(db->hashTables == ((void*) -1))
       {
-         //[Initialize rwlock attributes]
-         pthread_rwlockattr_t rwlattr, cache_rwlattr;
-         pthread_rwlockattr_init(&rwlattr);
-         pthread_rwlockattr_init(&cache_rwlattr);
-         pthread_rwlockattr_setpshared(&rwlattr, PTHREAD_PROCESS_SHARED);
-         pthread_rwlockattr_setpshared(&cache_rwlattr, PTHREAD_PROCESS_SHARED);
-         pthread_rwlock_init(&db->shmem_info->rwlock, &rwlattr);
-         pthread_rwlock_init(&db->shmem_info->cache_rwlock, &cache_rwlattr);
-         Kdb_wrlock(&db->shmem_info->rwlock);
-
-#ifdef __checkerror
-         //CHECK POWERLOSS FLAGS
-         ret = checkErrorFlags(db);
-         if (0 != ret)
-         {
-            close(db->fd);
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return ret;
-         }
-#endif
-         db->shmem_info->num_hash_tables = 0;
+         return KISSDB_ERROR_MAP_SHM;
       }
-      else // already initialized
-         Kdb_wrlock(&db->shmem_info->rwlock);
-
-      db->already_open = Kdb_true;
+      db->htMappedSize = firstMappSize;
+      db->alreadyOpen = Kdb_true;
    }
-   else
-      Kdb_wrlock(&db->shmem_info->rwlock);
 
-   //only read header from file into memory for first caller of KISSDB_open
-   if (db->shmem_creator == Kdb_true)
+   /*
+    *  Read hashtables from file into memory ONLY for first caller of KISSDB_open
+    *  Determine number of existing hashtables (db->shared->htNum)    *
+    */
+   if (db->shmCreator == Kdb_true )
    {
-      httmp = (Hashtable_slot_s*) malloc(db->hash_table_size_bytes);   //read hashtable from file
-      if (!httmp)
+      uint64_t offset = KISSDB_HEADER_SIZE;
+      //only read hashtables from file if file is larger than header + hashtable size
+      if(db->shared->mappedDbSize >= ( KISSDB_HEADER_SIZE + db->htSizeBytes) )
       {
-         close(db->fd);
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return KISSDB_ERROR_MALLOC;
-      }
-      while (read(db->fd, httmp, db->hash_table_size_bytes) == db->hash_table_size_bytes)
-      {
-         Kdb_bool result = Kdb_false;
-         //if new size would exceed old shared memory size-> allocate additional memory page to shared memory
-         if (db->hash_table_size_bytes * (db->shmem_info->num_hash_tables + 1) > db->old_mapped_size)
+         htptr = (Hashtable_s*) ( db->mappedDb + KISSDB_HEADER_SIZE);
+         htFound = Kdb_true;
+         while (htFound && offset < db->dbMappedSize )
          {
-            Kdb_bool temp;
-            if (db->shmem_ht_fd <= 0)
+            //check for existing start OR end delimiter of hashtable
+            if (htptr->delimStart == HASHTABLE_START_DELIMITER || htptr->delimEnd == HASHTABLE_END_DELIMITER)
             {
-               db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name,  db->old_mapped_size, &temp);
-               if(db->shmem_ht_fd < 0)
+               //if new size would exceed old shared memory size-> allocate additional memory page to shared memory
+               Kdb_bool result = Kdb_false;
+               if ( (db->htSizeBytes * (db->shared->htNum + 1)) > db->htMappedSize)
+               {
+                  Kdb_bool temp;
+                  if (db->htFd <= 0)
+                  {
+                     db->htFd = kdbShmemOpen(db->htName,  db->htMappedSize, &temp);
+                     if(db->htFd < 0)
+                     {
+                        return KISSDB_ERROR_OPEN_SHM;
+                     }
+                  }
+                  result = resizeKdbShmem(db->htFd, &db->hashTables, db->htMappedSize, db->htMappedSize + db->htSizeBytes);
+                  if (result == Kdb_false)
+                  {
+                     return KISSDB_ERROR_RESIZE_SHM;
+                  }
+                  else
+                  {
+                     db->shared->htShmSize = db->htMappedSize + db->htSizeBytes;
+                     db->htMappedSize = db->shared->htShmSize;
+                  }
+               }
+               // copy the current hashtable read from file to (htadress + (htsize  * htcount)) in memory
+               memcpy(((uint8_t*) db->hashTables) + (db->htSizeBytes * db->shared->htNum), htptr, db->htSizeBytes);
+               ++db->shared->htNum;
+
+               //read until all linked hashtables have been read
+               if (htptr->slots[db->htSize].offsetA ) //if a offset to a further hashtable exists
                {
-                  free(httmp);
-                  Kdb_unlock(&db->shmem_info->rwlock);
-                  return KISSDB_ERROR_OPEN_SHM;
+                  htptr = (Hashtable_s*) (db->mappedDb + htptr->slots[db->htSize].offsetA); //follow link to next hashtable
+                  offset = htptr->slots[db->htSize].offsetA;
+               }
+               else //no link to next hashtable or link is invalid
+               {
+                  htFound = Kdb_false;
                }
             }
-            result = resizeKdbShmem(db->shmem_ht_fd, &db->hash_tables, db->old_mapped_size, db->old_mapped_size + db->hash_table_size_bytes);
-            if (result == Kdb_false)
-            {
-               free(httmp);
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_RESIZE_SHM;
-            }
-            else
+            else //delimiters of first hashtable or linked hashtable are invalid
             {
-               db->shmem_info->shmem_size = db->old_mapped_size + db->hash_table_size_bytes;
-               db->old_mapped_size = db->old_mapped_size + db->hash_table_size_bytes;
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": hashtable delimiters are invalid -> rebuild not possible!"));
+               htFound = Kdb_false;
             }
          }
-         // copy the current hashtable read from file to (htadress + (htsize  * htcount)) in memory
-         memcpy(((uint8_t *) db->hash_tables) + (db->hash_table_size_bytes * db->shmem_info->num_hash_tables), httmp, db->hash_table_size_bytes);
-         ++db->shmem_info->num_hash_tables;
-
-         //read until all hash tables have been read
-         if (httmp[db->hash_table_size].offsetA) //if httable[hash_table_size] contains a offset to a further hashtable
+      }
+      /*
+       *  CHECK POWERLOSS FLAGS AND REBUILD DATABASE IF NECESSARY
+       */
+      if (db->shared->openMode != KISSDB_OPEN_MODE_RDONLY)
+      {
+         if (checkErrorFlags(db) != 0)
          {
-            //ONE MORE HASHTABLE FOUND
-            if (lseek(db->fd, httmp[db->hash_table_size].offsetA, SEEK_SET) == -1)
-            { //move the filepointer to the next hashtable in the file
-               KISSDB_close(db);
-               free(httmp);
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(": database was not closed correctly in last lifecycle!"));
+            if (verifyHashtableCS(db) != 0)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(": A hashtable is invalid -> Start rebuild of hashtables!"));
+               if (rebuildHashtables(db) != 0) //hashtables are corrupt, walk through the database and search for data blocks -> then rebuild the hashtables
+               {
+                  DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": hashtable rebuild failed!"));
+               }
+               else
+               {
+                  DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(__FUNCTION__); DLT_STRING(": hashtable rebuild successful!"));
+               }
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":Start datablock check / recovery!"));
+               recoverDataBlocks(db);
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":End datablock check / recovery!"));
+            }
+            else
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":Start datablock check / recovery!"));
+               recoverDataBlocks(db);
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":End datablock check / recovery!"));
             }
          }
-         else
-            break; // no further hashtables exist
       }
-      free(httmp);
    }
-
-   //printSharedHashtable(db);
-
-   Kdb_unlock(&db->shmem_info->rwlock);
+   Kdb_unlock(&db->shared->rwlock);
    return 0;
 }
 
 
-
-
-
-int KISSDB_close(KISSDB *db)
+int KISSDB_close(KISSDB* db)
 {
-   Kdb_wrlock(&db->shmem_info->rwlock);
+#ifdef PFS_TEST
+   printf("  START: KISSDB_CLOSE \n");
+#endif
 
-   uint64_t crc = 0;
+   Hashtable_s* htptr = NULL;
    Header_s* ptr = 0;
-#ifdef __showTimeMeasurements
-   long long KdbDuration = 0;
-   struct timespec mmapStart, mmapEnd;
-   KdbDuration = 0;
-#endif
+   uint64_t  crc = 0;
+
+   Kdb_wrlock(&db->shared->rwlock);
 
-   //printSharedHashtable(db);
-   if (db->shmem_creator == Kdb_true)
+   //if no other instance has opened the database
+   if( db->shared->refCount == 0)
    {
-      //free shared hashtable
-      if( freeKdbShmemPtr(db->hash_tables, db->old_mapped_size) == Kdb_false)
+      if (db->shared->openMode != KISSDB_OPEN_MODE_RDONLY)
       {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return KISSDB_ERROR_UNMAP_SHM;
+         if(db->htMappedSize < db->shared->htShmSize)
+         {
+            if ( Kdb_false == remapSharedHashtable(db->htFd, &db->hashTables, db->htMappedSize, db->shared->htShmSize))
+            {
+               return KISSDB_ERROR_RESIZE_SHM;
+            }
+            else
+            {
+               db->htMappedSize = db->shared->htShmSize;
+            }
+         }
+         //remap database file if in the meanwhile another process added new data (key value pairs / hashtables) to the file (only happens if writethrough is used)
+         if (db->dbMappedSize < db->shared->mappedDbSize)
+         {
+            db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize, MREMAP_MAYMOVE);
+            if (db->mappedDb == MAP_FAILED)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"), DLT_STRING(strerror(errno)));
+               return KISSDB_ERROR_IO;
+            }
+            else
+            {
+               db->dbMappedSize = db->shared->mappedDbSize;
+            }
+         }
+
+         // generate checksum for every hashtable and write crc to file
+         if (db->fd)
+         {
+            int i = 0;
+            int offset = sizeof(Header_s); //offset in file to first hashtable
+            if (db->shared->htNum > 0) //if hashtables exist
+            {
+               //write hashtables and crc to file
+               for (i = 0; i < db->shared->htNum; i++)
+               {
+                  crc = 0;
+                  crc = (uint64_t) pcoCrc32(crc, (unsigned char*) db->hashTables[i].slots, sizeof(db->hashTables[i].slots));
+                  db->hashTables[i].crc = crc;
+                  htptr = (Hashtable_s*) (db->mappedDb +  offset);
+                  //copy hashtable and generated crc from shared memory to mapped hashtable in file
+                  memcpy(htptr, &db->hashTables[i], db->htSizeBytes);
+                  offset = db->hashTables[i].slots[db->htSize].offsetA;
+               }
+            }
+         }
+         //update header (close flags)
+         ptr = (Header_s*) db->mappedDb;
+         ptr->closeFailed = 0x00; //remove closeFailed flag
+         ptr->closeOk = 0x01;     //set closeOk flag
+         msync(db->mappedDb, KISSDB_HEADER_SIZE, MS_SYNC);
       }
-      if( kdbShmemClose(db->shmem_ht_fd, db->shmem_ht_name) == Kdb_false)
-         return KISSDB_ERROR_CLOSE_SHM;
 
-      free(db->shmem_ht_name);
-      Kdb_unlock(&db->shmem_info->rwlock);
-      pthread_rwlock_destroy(&db->shmem_info->rwlock);
-      pthread_rwlock_destroy(&db->shmem_info->cache_rwlock);
+      //unmap whole database file
+      munmap(db->mappedDb, db->dbMappedSize);
+      db->mappedDb = NULL;
 
-      // free shared information
-      if (freeKdbShmemPtr(db->shmem_info, sizeof(Kdb_bool)) == Kdb_false)
-         return KISSDB_ERROR_UNMAP_SHM;
-      if (kdbShmemClose(db->shmem_info_fd, db->shmem_info_name) == Kdb_false)
+      //unmap shared hashtables
+      munmap(db->hashTables, db->htMappedSize);
+      db->hashTables = NULL;
+      //close shared memory for hashtables
+      if( kdbShmemClose(db->htFd, db->htName) == Kdb_false)
+      {
+         close(db->fd);
+         Kdb_unlock(&db->shared->rwlock);
          return KISSDB_ERROR_CLOSE_SHM;
-      free(db->shmem_info_name);
+      }
+      db->htFd = 0;
 
-#ifdef __showTimeMeasurements
-      clock_gettime(CLOCK_ID, &mmapStart);
-#endif
+      if(db->htName != NULL)
+      {
+         free(db->htName);
+         db->htName = NULL;
+      }
 
-      //update header (checksum and flags)
-      int mapFlag = PROT_WRITE | PROT_READ;
-      ptr = (Header_s*) mmap(NULL,KISSDB_HEADER_SIZE, mapFlag, MAP_SHARED, db->fd, 0);
-      if (ptr == MAP_FAILED)
+      //free rwlocks
+      Kdb_unlock(&db->shared->rwlock);
+      pthread_rwlock_destroy(&db->shared->rwlock);
+
+      // unmap shared information
+      munmap(db->shared, sizeof(Shared_Data_s));
+      db->shared = NULL;
+
+      if (kdbShmemClose(db->sharedFd, db->sharedName) == Kdb_false)
       {
          close(db->fd);
-         return KISSDB_ERROR_IO;
+         return KISSDB_ERROR_CLOSE_SHM;
       }
-#ifdef __checkerror
-      // generate checksum over database file (beginning at file offset [sizeof(ptr->KdbV) + sizeof(ptr->checksum)] up to EOF)
-      if( db->fd )
+      db->sharedFd =0;
+      if(db->sharedName != NULL)
       {
-         crc = 0;
-         crc = (uint64_t) pcoCalcCrc32Csum(db->fd, sizeof(Header_s) );
-         ptr->checksum =  crc;
-         //printf("CLOSING ------ DB: %s, WITH CHECKSUM CALCULATED: %" PRIu64 "  \n", db->shmem_ht_name, ptr->checksum);
+         free(db->sharedName);
+         db->sharedName = NULL;
       }
-#endif
-      ptr->closeFailed = 0x00; //remove closeFailed flag
-      ptr->closeOk = 0x01;     //set closeOk flag
-
-      //sync changes with file
-      if( 0 != msync(ptr, KISSDB_HEADER_SIZE, MS_SYNC  | MS_INVALIDATE))
+      if(db->cacheName != NULL)
       {
-         close(db->fd);
-         return KISSDB_ERROR_IO;
+        free(db->cacheName); //free memory for name  obtained by kdbGetShmName() function
+        db->cacheName = NULL;
       }
-      //unmap memory
-      if( 0 != munmap(ptr, KISSDB_HEADER_SIZE))
+      if( db->fd)
       {
          close(db->fd);
-         return KISSDB_ERROR_IO;
+         db->fd = 0;
+      }
+
+      db->alreadyOpen = Kdb_false;
+      db->htSize = 0;
+      //db->cacheReferenced = 0;
+      db->keySize = 0;
+      db->valSize = 0;
+      db->htSizeBytes = 0;
+      db->htMappedSize = 0;
+      db->dbMappedSize = 0;
+      db->shmCreator = 0;
+      db->alreadyOpen = 0;
+
+      //destroy named semaphore
+      if (-1 == sem_post(db->kdbSem)) //release semaphore
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                 DLT_STRING(__FUNCTION__); DLT_STRING(": sem_post() failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      if (-1 == sem_close(db->kdbSem))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                 DLT_STRING(__FUNCTION__); DLT_STRING(": sem_close() failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      if (-1 == sem_unlink(db->semName))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                 DLT_STRING(__FUNCTION__); DLT_STRING(": sem_unlink() failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      db->kdbSem = NULL;
+      if(db->semName != NULL)
+      {
+         free(db->semName);
+         db->semName = NULL;
       }
-#ifdef __showTimeMeasurements
-      clock_gettime(CLOCK_ID, &mmapEnd);
-      KdbDuration += getNsDuration(&mmapStart, &mmapEnd);
-      printf("mmap duration for => %f ms\n", (double)((double)KdbDuration/NANO2MIL));
-#endif
-      fsync(db->fd);
+
+   }
+   else
+   {
+      //if caller of close is not the last instance using the database
+      //unmap whole database file
+      munmap(db->mappedDb, db->dbMappedSize);
+      db->mappedDb = NULL;
+
+      //unmap shared hashtables
+      munmap(db->hashTables, db->htMappedSize);
+      db->hashTables = NULL;
 
       if( db->fd)
+      {
          close(db->fd);
+         db->fd = 0;
+      }
+      if(db->htFd)
+      {
+         close(db->htFd);
+         db->htFd = 0;
+      }
+
+      db->alreadyOpen = Kdb_false;
+      db->htSize = 0;
+      //db->cacheReferenced = 0;
+      db->keySize = 0;
+      db->valSize = 0;
+      db->htSizeBytes = 0;
+      db->htMappedSize = 0;
+      db->dbMappedSize = 0;
+      db->shmCreator = 0;
+      db->alreadyOpen = 0;
 
-      db->already_open = Kdb_false;
-      //memset(db, 0, sizeof(KISSDB)); //todo check if necessary
+      Kdb_unlock(&db->shared->rwlock);
+
+      // unmap shared information
+      munmap(db->shared, sizeof(Shared_Data_s));
+      db->shared = NULL;
+
+      if(db->sharedFd)
+      {
+         close(db->sharedFd);
+         db->sharedFd = 0;
+      }
+      if(db->htName != NULL)
+      {
+         free(db->htName);
+         db->htName = NULL;
+      }
+      if(db->sharedName != NULL)
+      {
+         free(db->sharedName);
+         db->sharedName = NULL;
+      }
+      if(db->cacheName != NULL)
+      {
+        free(db->cacheName); //free memory for name  obtained by kdbGetShmName() function
+        db->cacheName = NULL;
+      }
+      //clean struct
+      if (-1 == sem_post(db->kdbSem))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                 DLT_STRING(__FUNCTION__); DLT_STRING(": sem_post() in close failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      if (-1 == sem_close(db->kdbSem))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                 DLT_STRING(__FUNCTION__); DLT_STRING(": sem_close() in close failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      db->kdbSem = NULL;
+      if(db->semName != NULL)
+      {
+         free(db->semName);
+         db->semName = NULL;
+      }
    }
-   else
-      //if caller is not the creator of the lock
-      Kdb_unlock(&db->shmem_info->rwlock);
+#ifdef PFS_TEST
+   printf("  END: KISSDB_CLOSE \n");
+#endif
    return 0;
 }
 
 
-int KISSDB_get(KISSDB *db, const void *key, void *vbuf)
+int KISSDB_get(KISSDB* db, const void* key, void* vbuf, uint32_t bufsize, uint32_t* vsize)
 {
-   Kdb_rdlock(&db->shmem_info->rwlock);
-
-   uint8_t tmp[TMP_BUFFER_LENGTH];
-   uint64_t current;
-   const uint8_t *kptr;
+   const uint8_t* kptr;
+   DataBlock_s* block;
+   Hashtable_slot_s* hashTable;
+   int64_t offset;
+   Kdb_bool bCanContinue = Kdb_true;
+   Kdb_bool bKeyFound = Kdb_false;
+   uint64_t hash = 0;
    unsigned long klen, i;
-   long n = 0;
-   uint64_t checksum, backupChecksum, crc;
-   uint64_t hash = KISSDB_hash(key, db->key_size) % (uint64_t) db->hash_table_size;
-   int64_t offset, backupOffset, htoffset, checksumOffset, flagOffset; //lasthtoffset
-   Hashtable_slot_s *cur_hash_table;
-
-#ifdef __writeThrough
-   //if new one or more hashtables were appended, remap shared memory block to adress space
-   if (db->old_mapped_size < db->shmem_info->shmem_size)
-   {
-      Kdb_bool temp;
-      db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name, db->old_mapped_size, &temp);
-      if(db->shmem_ht_fd < 0)
-         return KISSDB_ERROR_OPEN_SHM;
-      res = remapKdbShmem(db->shmem_ht_fd, &db->hash_tables, db->old_mapped_size, db->shmem_info->shmem_size);
-      if (res == Kdb_false)
-         return KISSDB_ERROR_REMAP_SHM;
-      db->old_mapped_size = db->shmem_info->shmem_size;
+
+   klen = strlen(key);
+   hash = KISSDB_hash(key, klen) % (uint64_t) db->htSize;
+
+   if(db->htMappedSize < db->shared->htShmSize)
+   {
+      if ( Kdb_false == remapSharedHashtable(db->htFd, &db->hashTables, db->htMappedSize, db->shared->htShmSize))
+      {
+         return KISSDB_ERROR_RESIZE_SHM;
+      }
+      else
+      {
+         db->htMappedSize = db->shared->htShmSize;
+      }
    }
-#endif
 
-   htoffset = KISSDB_HEADER_SIZE; //lasthtoffset
-   cur_hash_table = db->hash_tables;//pointer to current hashtable in memory
-   for (i = 0; i < db->shmem_info->num_hash_tables; ++i)
+   hashTable = db->hashTables[0].slots; //pointer to first hashtable in memory at first slot
+
+   if (db->dbMappedSize < db->shared->mappedDbSize)
+   {
+      db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize, MREMAP_MAYMOVE);
+      if (db->mappedDb == MAP_FAILED)
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"), DLT_STRING(strerror(errno)));
+         return KISSDB_ERROR_IO;
+      }
+      else
+      {
+         db->dbMappedSize = db->shared->mappedDbSize;
+      }
+   }
+
+
+   for (i = 0; i < db->shared->htNum; ++i)
    {
-      offset = cur_hash_table[hash].offsetA;//get fileoffset where the data can be found in the file
-#ifdef __useBackups
       //get information about current valid offset to latest written data
-      if(cur_hash_table[hash].current == 0x00) //valid is offsetA
+      offset = (hashTable[hash].current == 0x00) ? hashTable[hash].offsetA : hashTable[hash].offsetB; // if 0x00 -> offsetA is latest else offsetB is latest
+      if(offset < 0) //deleted or invalidated data but search in next hashtable
       {
-         offset  = cur_hash_table[hash].offsetA;
-         checksum = cur_hash_table[hash].checksumA;
+         bCanContinue = Kdb_false; //deleted datablock -> do not compare the key
       }
       else
       {
-         offset = cur_hash_table[hash].offsetB;
-         checksum = cur_hash_table[hash].checksumB;
+         bCanContinue = Kdb_true; //possible match -> compare the key
       }
-#endif
 
-      if (offset >= KISSDB_HEADER_SIZE)       //if a valid offset is available in the slot
+      if(Kdb_true == bCanContinue)
       {
-         if (lseek(db->fd, offset, SEEK_SET) == -1) //move filepointer to this offset
+         if( abs(offset) > db->dbMappedSize )
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
             return KISSDB_ERROR_IO;
          }
-         kptr = (const uint8_t *) key;
-         klen = db->key_size;
-         while (klen)
+         if (offset >= KISSDB_HEADER_SIZE) //if a valid offset is available in the slot
          {
-            n = (long) read(db->fd, tmp, (klen > sizeof(tmp)) ? sizeof(tmp) : klen);
-            if (n > 0)
-            {
-               if (memcmp(kptr, tmp, n))//if key does not match -> search in next hashtable
-                  goto get_no_match_next_hash_table;
-               kptr += n;
-               klen -= (unsigned long) n;
-            }
-            else
+            block = (DataBlock_s*) (db->mappedDb +  offset);
+            kptr = (const uint8_t*) key;
+            if (klen > 0)
             {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return 1; /* not found */
+               if (memcmp(kptr, block->key, klen)
+                     || strlen(block->key) != klen) //if search key does not match with key in file
+               {
+                  bKeyFound = Kdb_false;
+               }
+               else
+               {
+                  bKeyFound = Kdb_true;
+               }
             }
-         }
-         if (read(db->fd, vbuf, db->value_size) == db->value_size) //if key matches at the fileoffset -> read the value
-         {
-            //crc check for file content
-#ifdef __useBackups
-            //only validate checksums at read if checksum of file is invalid
-            if (db->shmem_info->crc_invalid == Kdb_true)
+            if(Kdb_true == bKeyFound)
             {
-               //verify checksum of current key/value pair
-               crc = 0;
-               crc = (uint64_t) pcoCrc32(crc, (unsigned char*) vbuf, db->value_size);
-               if (checksum != crc)
+               //copy found value if buffer is big enough
+               if(bufsize >= block->valSize)
                {
-                  //printf("KISSDB_get: WARNING: checksum invalid -> try to read from valid data block \n");
-                  //try to read valid data from backup
-                  Hashtable_slot_s slot = cur_hash_table[hash];
-                  if (cur_hash_table[hash].current == 0x00) //current is offsetA, but Data there is corrupt--> so use offsetB as backupOffset
-                  {
-                     backupOffset = cur_hash_table[hash].offsetB;
-                     backupChecksum = cur_hash_table[hash].checksumB;
-                     checksumOffset = htoffset + (sizeof(Hashtable_slot_s) * hash + sizeof(slot.offsetA)); //offset that points to checksumA
-                     current = 0x01; //current is offsetB
-                  }
-                  else
-                  {
-                     backupOffset = cur_hash_table[hash].offsetA;
-                     backupChecksum = cur_hash_table[hash].checksumA;
-                     checksumOffset = htoffset
-                           + (sizeof(Hashtable_slot_s) * hash + sizeof(slot.offsetA) + sizeof(slot.checksumA)
-                                 + sizeof(slot.offsetB)); //offset that points to checksumB
-                     current = 0x00;
-                  }
-                  flagOffset = htoffset
-                        + (sizeof(Hashtable_slot_s) * hash + (sizeof(Hashtable_slot_s) - sizeof(slot.current))); //offset that points to currentflag
-
-                  //seek to backup data
-                  if (lseek(db->fd, backupOffset + db->key_size, SEEK_SET) == -1) //move filepointer to data of key-value pair //TODO make checksum over key AND data ??
-                  {
-                     Kdb_unlock(&db->shmem_info->rwlock);
-                     return KISSDB_ERROR_IO;
-                  }
-
-                  //verify checksum of backup key/value pair
-                  //read from backup data
-                  if (read(db->fd, vbuf, db->value_size) == db->value_size) //read value of backup Data block
-                  {
-                     //generate checksum of backup
-                     crc = 0;
-                     crc = (uint64_t) pcoCrc32(crc, (unsigned char*) vbuf, db->value_size);
-                     if (crc == backupChecksum)  //if checksum ok
-                     {
-                        //printf("KISSDB_get: WARNING: OVERWRITING CORRUPT DATA \n");
-                        //seek to corrupt data
-                        if (lseek(db->fd, offset + db->key_size, SEEK_SET) == -1) //move filepointer to data of corrupt key-value pair
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        //overwrite corrupt data
-                        if (write( db->fd, vbuf, db->value_size) != db->value_size )  //write value
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        //seek to header slot and update checksum of corrupt data (do not modify offsets)
-                        if (lseek(db->fd, checksumOffset, SEEK_SET) == -1) //move to checksumX in file
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        if (write( db->fd, &crc, sizeof(uint64_t)) != sizeof(uint64_t) )  //write checksumX to hashtbale slot
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        //update checksumX in memory
-                        if (cur_hash_table[hash].current == 0x00) //current is offsetA, but Data there is corrupt--> so update checksumA with new checksum
-                           cur_hash_table[hash].checksumA = crc;
-                        else
-                           cur_hash_table[hash].checksumB = crc;
-                        //switch current valid to backup
-
-                        if (lseek(db->fd, flagOffset, SEEK_SET) == -1) //move to current flag in file
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        if (write( db->fd, &current, sizeof(uint64_t)) != sizeof(uint64_t) )     //write current hashtable slot in file
-                        {
-                           Kdb_unlock(&db->shmem_info->rwlock);
-                           return KISSDB_ERROR_IO;
-                        }
-                        //update current valid in memory
-                        cur_hash_table[hash].current = current;
-                        //fsync(db->fd)
-                        Kdb_unlock(&db->shmem_info->rwlock);
-                        return 0; /* success */
-                     }
-                     else //if checksum not valid, return NOT FOUND
-                     {
-                        Kdb_unlock(&db->shmem_info->rwlock);
-                        return 1; /* not found */
-                     }
-                  }
-                  else
-                  {
-                     Kdb_unlock(&db->shmem_info->rwlock);
-                     return KISSDB_ERROR_IO;
-                  }
+                  memcpy(vbuf, block->value, block->valSize);
                }
+               *(vsize) = block->valSize;
+               return 0; /* success */
             }
-#endif
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return 0; /* success */
          }
          else
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
+            return 1; /* not found */
          }
       }
-      else
-      {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return 1; /* not found */
-      }
-      //get_no_match_next_hash_table: cur_hash_table += db->hash_table_size + 1;
-      get_no_match_next_hash_table:  //update lastht offset //lasthtoffset = htoffset
-      htoffset = cur_hash_table[db->hash_table_size].offsetA; // fileoffset to the next file-hashtable
-      cur_hash_table += (db->hash_table_size + 1); //pointer to the next memory-hashtable
+      hashTable = (Hashtable_slot_s*) ((char*) hashTable + sizeof(Hashtable_s));  //pointer to the next memory-hashtable
    }
-   Kdb_unlock(&db->shmem_info->rwlock);
    return 1; /* not found */
 }
 
 
-//TODO check current valid data to be deleted ?
-int KISSDB_delete(KISSDB *db, const void *key)
+int KISSDB_delete(KISSDB* db, const void* key, int32_t* bytesDeleted)
 {
-   Kdb_wrlock(&db->shmem_info->rwlock);
-
-   uint8_t tmp[TMP_BUFFER_LENGTH];
-   //uint64_t current = 0x00;
-   const uint8_t *kptr;
-   long n;
-   unsigned long klen, i;
-   //uint64_t crc = 0x00;
-   uint64_t hash = KISSDB_hash(key, db->key_size) % (uint64_t) db->hash_table_size;
-   //int64_t empty_offset = 0;
-   int64_t empty_offsetB = 0;
+   const uint8_t* kptr;
+   DataBlock_s* backupBlock;
+   DataBlock_s* block;
+   Hashtable_slot_s* hashTable;
+   int64_t backupOffset = 0;
    int64_t offset = 0;
-   int64_t htoffset = 0;
-   Hashtable_slot_s *cur_hash_table;
+   Kdb_bool bCanContinue = Kdb_true;
+   Kdb_bool bKeyFound = Kdb_false;
+   uint64_t hash = 0;
+   uint64_t crc = 0x00;
+   unsigned long klen, i;
+
+   klen = strlen(key);
+   hash = KISSDB_hash(key, klen) % (uint64_t) db->htSize;
+   *(bytesDeleted) = PERS_COM_ERR_NOT_FOUND;
 
-#ifdef __writeThrough
-   //if new hashtable was appended, remap shared memory block to adress space
-   if (db->old_mapped_size < db->shmem_info->shmem_size)
+   if(db->htMappedSize < db->shared->htShmSize)
    {
-      Kdb_bool temp;
-      db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name, db->old_mapped_size, &temp);
-      if(db->shmem_ht_fd < 0)
-         return KISSDB_ERROR_OPEN_SHM;
-      result = remapKdbShmem(db->shmem_ht_fd, &db->hash_tables, db->old_mapped_size, db->shmem_info->shmem_size);
-      if (result == Kdb_false)
-         return KISSDB_ERROR_REMAP_SHM;
-      db->old_mapped_size = db->shmem_info->shmem_size;
+      if ( Kdb_false == remapSharedHashtable(db->htFd, &db->hashTables, db->htMappedSize, db->shared->htShmSize))
+      {
+         return KISSDB_ERROR_RESIZE_SHM;
+      }
+      else
+      {
+         db->htMappedSize = db->shared->htShmSize;
+      }
    }
-#endif
 
-   htoffset = KISSDB_HEADER_SIZE;
-   cur_hash_table = db->hash_tables; //pointer to current hashtable in memory
+   hashTable = db->hashTables->slots; //pointer to current hashtable in memory
 
-   for (i = 0; i < db->shmem_info->num_hash_tables; ++i)
+   //remap database file if in the meanwhile another process added new data (key value pairs / hashtables) to the file
+   if (db->dbMappedSize < db->shared->mappedDbSize)
    {
-      offset = cur_hash_table[hash].offsetA; //get fileoffset where the data can be found in the file
-      if (offset >= KISSDB_HEADER_SIZE)
+      db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize, MREMAP_MAYMOVE);
+      if (db->mappedDb == MAP_FAILED)
       {
-         if (lseek(db->fd, offset, SEEK_SET) == -1)
-         {
-            //set filepointer to Key value offset in file
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         kptr = (const uint8_t *) key;
-         klen = db->key_size;
-         while (klen)
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"), DLT_STRING(strerror(errno)));
+         return KISSDB_ERROR_IO;
+      }
+      db->dbMappedSize = db->shared->mappedDbSize;
+   }
+
+   for (i = 0; i < db->shared->htNum; ++i)
+   {
+      //get information about current valid offset to latest written data
+      if (hashTable[hash].current == 0x00) //valid is offsetA
+      {
+         offset = hashTable[hash].offsetA;
+         backupOffset = hashTable[hash].offsetB;
+      }
+      else
+      {
+         offset = hashTable[hash].offsetB;
+         backupOffset = hashTable[hash].offsetA;
+      }
+      if (offset < 0) //deleted or invalidated data but search in next hashtable
+      {
+         bCanContinue = Kdb_false;
+      }
+      else
+      {
+         bCanContinue = Kdb_true;
+      }
+      if (Kdb_true == bCanContinue)
+      {
+         if (offset >= KISSDB_HEADER_SIZE)
          {
-            n = (long) read(db->fd, tmp, (klen > sizeof(tmp)) ? sizeof(tmp) : klen);
-            if (n > 0)
+            if( abs(offset) > db->dbMappedSize || abs(backupOffset) >  db->dbMappedSize)
             {
-               if (memcmp(kptr, tmp, n))//if key does not match, search in next hashtable
-                  goto get_no_match_next_hash_table;
-               kptr += n;
-               klen -= (unsigned long) n;
+               return KISSDB_ERROR_IO;
             }
-            else
+
+            block = (DataBlock_s*) (db->mappedDb +  offset);
+            kptr = (const uint8_t*) key;  //pointer to search key
+            if (klen > 0)
             {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return 1; /* not found */
+               if (memcmp(kptr, block->key, klen) || strlen(block->key) != klen) //if search key does not match with key in file
+               {
+                  bKeyFound = Kdb_false;
+               }
+               else
+               {
+                  bKeyFound = Kdb_true;
+               }
+            }
+            /* data to be deleted was found
+             write "deleted block delimiters" for both blocks and delete key / value */
+            if (Kdb_true == bKeyFound)
+            {
+               block->delimStart = (offset < backupOffset) ? DATA_BLOCK_A_DELETED_START_DELIMITER : DATA_BLOCK_B_DELETED_START_DELIMITER;
+               //memset(block->key,   0, db->keySize); //do not delete key -> used in hashtable rebuild
+               memset(block->value, 0, db->valSize);
+               block->valSize = 0;
+               crc = 0x00;
+               crc = (uint32_t) pcoCrc32(crc, (unsigned char*)block->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t) );
+               block->crc = crc;
+               block->delimEnd = (offset < backupOffset) ? DATA_BLOCK_A_DELETED_END_DELIMITER : DATA_BLOCK_B_DELETED_END_DELIMITER;
+
+               backupBlock = (DataBlock_s*) (db->mappedDb +  backupOffset);  //map data and backup block
+
+               backupBlock->delimStart = (backupOffset < offset) ? DATA_BLOCK_A_DELETED_START_DELIMITER : DATA_BLOCK_B_DELETED_START_DELIMITER;
+               //memset(backupBlock->key,   0, db->keySize);
+               memset(backupBlock->value, 0, db->valSize);
+               backupBlock->valSize = 0;
+               crc = 0x00;
+               crc = (uint32_t) pcoCrc32(crc, (unsigned char*)backupBlock->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t) );
+               backupBlock->crc = crc;
+               backupBlock->delimEnd = (backupOffset < offset) ? DATA_BLOCK_A_DELETED_END_DELIMITER : DATA_BLOCK_B_DELETED_END_DELIMITER;
+
+
+               //negate offsetB, delete checksums and current flag in memory
+               hashTable[hash].offsetA = -hashTable[hash].offsetA; //negate offset in hashtable that points to the data
+               hashTable[hash].offsetB = -hashTable[hash].offsetB;
+               hashTable[hash].current = 0x00;
+
+               *(bytesDeleted) = block->valSize;
+               return 0; /* success */
             }
          }
-         //TODO: mmap Hashtable slot structure to avoid seeking -> align hashtables at a multiple of a pagesize
-#ifdef __useFileMapping
-         empty_offsetB = -(offset + (db->key_size + db->value_size)); //todo check if offset is rewritten in put function !
-         cur_hash_table[hash].offsetB = empty_offsetB;
-         cur_hash_table[hash].checksumA = 0x00;
-         cur_hash_table[hash].checksumB = 0x00;
-         cur_hash_table[hash].current =   0x00;
-         int testoffset= lseek(fd, 0, SEEK_CUR); //filepointer position
-         int myoffset = htoffset + (sizeof(Hashtable_slot_s) * hash);
-
-         printf("Endoffset in file: %d , Offset for mmap: %d , size for mmap: %d \n", testoffset, myoffset, sizeof(Hashtable_slot_s));
-
-         //mmap the current hashtable slot
-         int mapFlag = PROT_WRITE | PROT_READ;
-         printf("In Delete: filedes: %d\n", db->fd);
-         htSlot = (Hashtable_slot_s*) mmap(NULL, sizeof(Hashtable_slot_s), mapFlag, MAP_SHARED, db->fd, htoffset + (sizeof(Hashtable_slot_s) * hash) ); //TODO offset must be a multiple of pagesize
-         if (htSlot == MAP_FAILED)
-         {
-            printf("MMAP ERROR !\n");
-            close(db->fd);
-            return KISSDB_ERROR_IO;
-         }
-         //do changes to slot in file
-         htSlot->offsetA = empty_offset;
-         htSlot->checksumA = 0x00;
-         htSlot->offsetB = empty_offsetB;
-         htSlot->checksumB = 0x00;
-         htSlot->current = 0x00;
-
-         //sync changes with file
-         if (0 != msync(htSlot,  sizeof(Hashtable_slot_s), MS_SYNC | MS_INVALIDATE))
-         {
-            close(db->fd);
-            return KISSDB_ERROR_IO;
-         }
-         //unmap memory
-         if (0 != munmap(htSlot,  sizeof(Hashtable_slot_s)))
-         {
-            close(db->fd);
-            return KISSDB_ERROR_IO;
-         }
-#endif
-         if (lseek(db->fd, htoffset + (sizeof(Hashtable_slot_s) * hash), SEEK_SET) == -1) //move Filepointer to used slot in file-hashtable.
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-
-#ifndef __useBackups
-         cur_hash_table[hash].offsetA = -offset; //negate offset in hashtable that points to the data
-         empty_offset = -offset;
-         //update hashtable slot in file header (delete existing offset information)
-         if (write( db->fd, &empty_offset, sizeof(int64_t)) != sizeof(int64_t) )  //mark slot in file-hashtable as deleted
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-#endif
-
-#ifdef __useBackups
-         //negate offsetB, delete checksums and current flag in memory
-         cur_hash_table[hash].offsetA = -offset; //negate offset in hashtable that points to the data
-         empty_offsetB = -(offset + (db->key_size + db->value_size));
-         cur_hash_table[hash].checksumA = 0x00;
-         cur_hash_table[hash].offsetB = empty_offsetB;
-         cur_hash_table[hash].checksumB = 0x00;
-         cur_hash_table[hash].current =   0x00;
-         if (write( db->fd, &cur_hash_table[hash], sizeof(Hashtable_slot_s)) != sizeof(Hashtable_slot_s) )  //write updated data in the file-hashtable slot
+         else
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
+            return 1; /* not found */ //if no offset is found at hashed position in slots
          }
-#endif
-         //TODO currently, no synchronus Filedescriptor is used!!!! fsync after fflush is needed to do synchronus writes
-         //fsync(db->fd) // associating a file stream with a synchronous file descriptor means that an fsync() call is not needed on the file descriptor after the fflush()
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return 0; /* success */
-      }
-      else
-      {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return 1; /* not found */ //if no offset is found at hashed position in ht
       }
-      get_no_match_next_hash_table: htoffset = cur_hash_table[db->hash_table_size].offsetA; // fileoffset to next ht in file
-      cur_hash_table += (db->hash_table_size + 1); //pointer to next hashtable in memory
+      hashTable = (Hashtable_slot_s*) ((char*) hashTable + sizeof(Hashtable_s));  //pointer to the next memory-hashtable
    }
-   Kdb_unlock(&db->shmem_info->rwlock);
    return 1; /* not found */
 }
 
-int KISSDB_put(KISSDB *db, const void *key, const void *value)
-{
-   Kdb_wrlock(&db->shmem_info->rwlock);
+// To improve write amplifiction: sort the keys at writeback for sequential write
+//return offset where key would be written if Kissdb_put with same key is called
+//int determineKeyOffset(KISSDB* db, const void* key)
+//{
+//   /*
+//    * - hash the key,
+//    * - go through hashtables and get corresponding offset to hash
+//    * - if offset is negative return the inverse offset
+//    * - if key matches at file offset return this offset
+//    */
+//   return 0;
+//}
 
-   uint8_t tmp[TMP_BUFFER_LENGTH];
-   uint64_t current = 0x00;
-   const uint8_t *kptr;
-   unsigned long klen, i;
-   uint64_t hash = KISSDB_hash(key, db->key_size) % (uint64_t) db->hash_table_size;
-   int64_t offset, endoffset, htoffset, lasthtoffset;
-   Hashtable_slot_s *cur_hash_table;
+
+
+
+int KISSDB_put(KISSDB* db, const void* key, const void* value, int valueSize, int32_t* bytesWritten)
+{
+   const uint8_t* kptr;
+   DataBlock_s* backupBlock;
+   DataBlock_s* block;
+   Hashtable_s* hashtable;
+   Hashtable_s* htptr;
+   Hashtable_slot_s* hashTable;
+   int64_t offset, backupOffset, endoffset;
+   Kdb_bool bKeyFound = Kdb_false;
    Kdb_bool result = Kdb_false;
    Kdb_bool temp = Kdb_false;
    uint64_t crc = 0x00;
-   long n;
-   char delimiter[8] = "||||||||";
+   uint64_t hash = 0;
+   unsigned long klen, i;
 
-#ifdef __writeThrough
-   //if new hashtable was appended, remap shared memory block to adress space
-   if(db->old_mapped_size < db->shmem_info->shmem_size)
+   klen = strlen(key);
+   hash = KISSDB_hash(key, klen) % (uint64_t) db->htSize;
+   *(bytesWritten) = 0;
+
+   if(db->htMappedSize < db->shared->htShmSize)
    {
-      db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name,  db->old_mapped_size, &temp);
-      if(db->shmem_ht_fd < 0)
-         return KISSDB_ERROR_OPEN_SHM;
-      res = remapKdbShmem(db->shmem_ht_fd, &db->hash_tables, db->old_mapped_size,db->shmem_info->shmem_size);
-      if (res == Kdb_false)
-         return KISSDB_ERROR_REMAP_SHM;
-      db->old_mapped_size = db->shmem_info->shmem_size;
+      if ( Kdb_false == remapSharedHashtable(db->htFd, &db->hashTables, db->htMappedSize, db->shared->htShmSize))
+      {
+         return KISSDB_ERROR_RESIZE_SHM;
+      }
+      else
+      {
+         db->htMappedSize = db->shared->htShmSize;
+      }
    }
-#endif
-   lasthtoffset = htoffset = KISSDB_HEADER_SIZE;
-   cur_hash_table = db->hash_tables; //pointer to current hashtable in memory
 
-   for (i = 0; i < db->shmem_info->num_hash_tables; ++i)
+   hashTable = db->hashTables->slots; //pointer to current hashtable in memory
+
+   //remap database file (only necessary here in writethrough mode) if in the meanwhile another process added new data (key value pairs / hashtables) to the file
+   if (db->dbMappedSize < db->shared->mappedDbSize)
+   {
+      db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize, MREMAP_MAYMOVE);
+      if (db->mappedDb == MAP_FAILED)
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"), DLT_STRING(strerror(errno)));
+         return KISSDB_ERROR_IO;
+      }
+      db->dbMappedSize = db->shared->mappedDbSize;
+   }
+
+
+   for (i = 0; i < db->shared->htNum; ++i)
    {
-      offset = cur_hash_table[hash].offsetA;   //fileoffset to data in file
+      offset = hashTable[hash].offsetA;   //fileoffset to data in file
       if (offset >= KISSDB_HEADER_SIZE || offset < 0) //if a key with same hash is already in this slot or the same key must be overwritten
       {
+         if( abs(offset) > db->dbMappedSize )
+         {
+            return KISSDB_ERROR_IO;
+         }
+
          // if slot is marked as deleted, use this slot and negate the offset in order to reuse the existing data block
          if(offset < 0)
          {
             offset = -offset; //get original offset where data was deleted
             //printf("Overwriting slot for key: [%s] which was deleted before, offsetA: %d \n",key, offset);
-            if (lseek(db->fd, offset, SEEK_SET) == -1) //move filepointer to fileoffset where the key can be found
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-            if (write( db->fd, key, db->key_size) != db->key_size )  //write key
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-            if (write( db->fd, value, db->value_size) != db->value_size )  //write value
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
+            writeDualDataBlock(db, offset, i, key, klen, value, valueSize);
+            hashTable[hash].offsetA = offset; //write the offset to the data in the memory-hashtable slot
+            offset += sizeof(DataBlock_s);
+            hashTable[hash].offsetB = offset; //write the offset to the second databloxk in the memory-hashtable slot
+            hashTable[hash].current = 0x00;
+            *(bytesWritten) = valueSize;
 
-            // write same key and value again here because slot was deleted an can be reused like an initial write
-#ifdef __useBackups
-            if (write( db->fd, key, db->key_size) != db->key_size )  //write key
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-            if (write( db->fd, value, db->value_size) != db->value_size )  //write value
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-#endif
-            //seek back to hashtbale slot
-            if (lseek(db->fd, htoffset + (sizeof(Hashtable_slot_s) * hash), SEEK_SET) == -1) //move  to beginning of hashtable slot in file
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-
-#ifndef __useBackups
-            cur_hash_table[hash].offsetA = offset; //write the offset to the data in the memory-hashtable slot
-            if (write( db->fd, &offset, sizeof(int64_t)) != sizeof(int64_t) )  //write the offsetA to the data in the file-hashtable slot
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-#endif
-
-#ifdef __useBackups
-            crc = 0x00;
-            crc = (uint32_t) pcoCrc32(crc, (unsigned char*)value, db->value_size);
-            cur_hash_table[hash].offsetA = offset; //write the offset to the data in the memory-hashtable slot
-            cur_hash_table[hash].checksumA = crc;
-            offset += (db->key_size + db->value_size);
-            cur_hash_table[hash].offsetB = offset;          //write the offset to the data in the memory-hashtable slot
-            cur_hash_table[hash].checksumB = crc;
-            cur_hash_table[hash].current = 0x00;
-
-            if (write( db->fd, &cur_hash_table[hash], sizeof(Hashtable_slot_s)) != sizeof(Hashtable_slot_s) )  //write updated data in the file-hashtable slot
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-#endif
-            //fsync(db->fd) //associating a file stream with a synchronous file descriptor means that an fsync() call is not needed on the file descriptor after the fflush()
-            Kdb_unlock(&db->shmem_info->rwlock);
             return 0; /* success */
          }
-
          //overwrite existing if key matches
-         // if cur_hash_table[hash].current == 0x00 -> offsetA is latest so write to offsetB else offsetB is latest and write to offsetA
-#ifdef __useBackups
-         if( cur_hash_table[hash].current == 0x00 )
-            offset = cur_hash_table[hash].offsetA; //0x00 -> offsetA is latest
-         else
-            offset = cur_hash_table[hash].offsetB; //else offsetB is latest
-#endif
-         if (lseek(db->fd, offset, SEEK_SET) == -1) //move filepointer to fileoffset where valid data can be found
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-
-         kptr = (const uint8_t *) key; //pointer to search key
-         klen = db->key_size;
-         while (klen)
-         {
-            n = (long) read(db->fd, tmp, (klen > sizeof(tmp)) ? sizeof(tmp) : klen);
-            if (n > 0)
-            {
-               if (memcmp(kptr, tmp, n)) //if search key does not match with key in file
-                  goto put_no_match_next_hash_table;
-               kptr += n;
-               klen -= (unsigned long) n;
-            }
-         }
-
-         //if key matches -> seek to currently non valid data block for this key
-#ifdef __useBackups
-         if( cur_hash_table[hash].current == 0x00 )
-            offset = cur_hash_table[hash].offsetB; // 0x00 -> offsetA is latest so write new data to offsetB which holds old data
-         else
-            offset = cur_hash_table[hash].offsetA; // offsetB is latest so write new data to offsetA which holds old data
-
-         if (lseek(db->fd, offset, SEEK_SET) == -1)//move filepointer to fileoffset where backup data can be found
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         if (write( db->fd, key, db->key_size) != db->key_size )  //write key
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-#endif
-         if (write( db->fd, value, db->value_size) != db->value_size )
+         offset = (hashTable[hash].current == 0x00) ? hashTable[hash].offsetA : hashTable[hash].offsetB; // if 0x00 -> offsetA is latest else offsetB is latest
+         block = (DataBlock_s*) (db->mappedDb +  offset);
+         kptr = (const uint8_t*) key;  //pointer to search key
+         if (klen > 0)
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         // seek back to slot in header for update of checksum and flag
-         if (lseek(db->fd, htoffset + (sizeof(Hashtable_slot_s) * hash), SEEK_SET) == -1) //move  to beginning of hashtable slot in file
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-
-         //generate crc for value
-         crc = 0x00;
-         crc = (uint64_t) pcoCrc32(crc, (unsigned char*)value, db->value_size);
-         current = 0x00;
-         Hashtable_slot_s slot = cur_hash_table[hash];
-
-         // check current flag and decide what parts of hashtable slot in file must be updated
-         if( cur_hash_table[hash].current == 0x00 ) //offsetA is latest -> modify settings of B
-         {
-            int seek = sizeof(slot.offsetA) + sizeof(slot.checksumA) + sizeof(slot.offsetB);
-            lseek(db->fd, seek , SEEK_CUR);                //move to checksumB in file
-            if( write( db->fd, &crc, sizeof(uint64_t)) != sizeof(uint64_t))      //write checksumB to file
+            if (memcmp(kptr, block->key, klen)
+                  || strlen(block->key) != klen) //if search key does not match with key in file
             {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
+               //if key does not match -> search in next hashtable
+               bKeyFound = Kdb_false;
             }
-            current = 0x01;
-            if( write( db->fd, &current, sizeof(uint64_t)) != sizeof(uint64_t))   //write current  to hashtbale slot
+            else
             {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
+               bKeyFound = Kdb_true;
             }
-            cur_hash_table[hash].checksumB = crc;
-            cur_hash_table[hash].current = current;
          }
-         else //offsetB is latest -> modify settings of A
+         if(Kdb_true == bKeyFound)
          {
+            backupOffset = (hashTable[hash].current == 0x00) ? hashTable[hash].offsetB : hashTable[hash].offsetA; // if 0x00 -> offsetB is latest backup  else offsetA is latest
 
-            int seek = sizeof(slot.offsetA);
-            lseek(db->fd, seek , SEEK_CUR); //move to checksumA in file
-            if( write( db->fd, &crc, sizeof(uint64_t)) != sizeof(uint64_t))   //write checksumA to file
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-            seek = sizeof(slot.offsetB) + sizeof(slot.checksumB);;
-            lseek(db->fd, seek , SEEK_CUR); //move to checksumA in file
-            current = 0x00;
-            if( write( db->fd, &current, sizeof(uint64_t)) != sizeof(uint64_t))//write current  to hashtbale slot
-            {
-               Kdb_unlock(&db->shmem_info->rwlock);
-               return KISSDB_ERROR_IO;
-            }
-            cur_hash_table[hash].checksumA = crc;
-            cur_hash_table[hash].current = current;
+            //ALSO OVERWRITE LATEST VALID BLOCK to improve write amplification factor
+            block->delimStart = (offset < backupOffset) ? DATA_BLOCK_A_START_DELIMITER : DATA_BLOCK_B_START_DELIMITER;
+            block->valSize = valueSize;
+            memcpy(block->value,value, block->valSize);
+            block->htNum = i;
+            crc = 0x00;
+            crc = (uint32_t) pcoCrc32(crc, (unsigned char*)block->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t) );
+            block->crc = crc;
+            block->delimEnd = (offset < backupOffset) ? DATA_BLOCK_A_END_DELIMITER : DATA_BLOCK_B_END_DELIMITER;
+
+            //if key matches -> seek to currently non valid data block for this key
+            backupOffset = (hashTable[hash].current == 0x00) ? hashTable[hash].offsetB : hashTable[hash].offsetA; // if 0x00 -> offsetB is latest backup  else offsetA is latest
+            backupBlock = (DataBlock_s*) (db->mappedDb +  backupOffset);
+            //backupBlock->delimStart = DATA_BLOCK_START_DELIMITER;
+            backupBlock->delimStart = (backupOffset < offset) ? DATA_BLOCK_A_START_DELIMITER : DATA_BLOCK_B_START_DELIMITER;
+            backupBlock->valSize = valueSize;
+            memcpy(backupBlock->value,value, backupBlock->valSize);
+            backupBlock->htNum = i;
+            crc = 0x00;
+            crc = (uint32_t) pcoCrc32(crc, (unsigned char*)backupBlock->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t) );
+            backupBlock->crc = crc;
+            //backupBlock->delimEnd = DATA_BLOCK_END_DELIMITER;
+            backupBlock->delimEnd = (backupOffset < offset) ? DATA_BLOCK_A_END_DELIMITER : DATA_BLOCK_B_END_DELIMITER;
+            // check current flag and decide what parts of hashtable slot in file must be updated
+            hashTable[hash].current = (hashTable[hash].current == 0x00) ? 0x01 : 0x00; // if 0x00 -> offsetA is latest -> set to 0x01 else /offsetB is latest -> modify settings of A set 0x00
+            *(bytesWritten) = valueSize;
+
+            return 0; //success
          }
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return 0; //success
       }
       else //if key is not already inserted
       {
          /* add new data if an empty hash table slot is discovered */
-         if (lseek(db->fd, 0, SEEK_END) == -1) //filepointer to the end of the file
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         endoffset = lseek(db->fd, 0, SEEK_CUR); //filepointer position
-         if (write( db->fd, key, db->key_size) != db->key_size )
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         if (write( db->fd, value, db->value_size) != db->value_size )
+         endoffset = db->shared->mappedDbSize;
+         if ( -1 == endoffset) //filepointer to the end of the file
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
             return KISSDB_ERROR_IO;
          }
 
-         // write same key and value again here --> initial write
-#ifdef __useBackups
-         if (write( db->fd, key, db->key_size) != db->key_size )
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         if (write( db->fd, value, db->value_size) != db->value_size )
+         //truncate file -> data + backup block
+         if( ftruncate(db->fd, endoffset + ( sizeof(DataBlock_s) * 2) ) < 0)
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
             return KISSDB_ERROR_IO;
          }
-#endif
-         if (lseek(db->fd, htoffset + (sizeof(Hashtable_slot_s) * hash), SEEK_SET) == -1) //move filepointer to file-hashtable slot in file (offsetA)
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-#ifndef __useBackups
-         if (write( db->fd, &endoffset, sizeof(int64_t)) != sizeof(int64_t) )  //write the offsetA to the data in the file-hashtable slot
-         {
-            Kdb_unlock(&db->shmem_info->rwlock);
-            return KISSDB_ERROR_IO;
-         }
-         cur_hash_table[hash].offsetA = endoffset; //write the offsetA to the data in the memory-hashtable slot
-#endif
 
-#ifdef __useBackups
-         crc = 0x00;
-         crc = (uint64_t) pcoCrc32(crc, (unsigned char*) value, db->value_size);
-         offset = endoffset + (db->key_size + db->value_size);
-         cur_hash_table[hash].offsetA = endoffset; //write the offsetA to the data in the memory-hashtable slot
-         cur_hash_table[hash].checksumA = crc;
-         cur_hash_table[hash].offsetB = offset;          //write the offset to the data in the memory-hashtable slot
-         cur_hash_table[hash].checksumB = crc;
-         cur_hash_table[hash].current = 0x00;
-         current = 0x00; //current
-
-         if (write( db->fd, &cur_hash_table[hash], sizeof(Hashtable_slot_s)) != sizeof(Hashtable_slot_s) )  //write updated data in the file-hashtable slot
+         db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize + (sizeof(DataBlock_s) * 2), MREMAP_MAYMOVE);
+         if (db->mappedDb == MAP_FAILED)
          {
-            Kdb_unlock(&db->shmem_info->rwlock);
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"),DLT_STRING(strerror(errno)));
             return KISSDB_ERROR_IO;
          }
-#endif
-         //fsync(db->fd) // associating a file stream with a synchronous file descriptor means that an fsync() call is not needed on the file descriptor after the fflush()
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return 0; /* success */
-      }
-      put_no_match_next_hash_table: lasthtoffset = htoffset;
-      htoffset = cur_hash_table[db->hash_table_size].offsetA; // fileoffset to the next file-hashtable
-      cur_hash_table += (db->hash_table_size + 1); //pointer to the next memory-hashtable
-   }
 
-   /* if no existing slots, add a new page of hash table entries */
-   if (lseek(db->fd, 0, SEEK_END) == -1) //Filepointer to the end of file
-   {
-      Kdb_unlock(&db->shmem_info->rwlock);
-      return KISSDB_ERROR_IO;
-   }
-   if(db->shmem_info->num_hash_tables > 0) //only write delimiter if first hashtable has been written (first delimiter is written by open call)
-   {
-      if (write( db->fd, &delimiter, sizeof(delimiter)) != sizeof(delimiter) )  //write delimiter
-      {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return KISSDB_ERROR_IO;
+         db->shared->mappedDbSize = db->shared->mappedDbSize + (sizeof(DataBlock_s) * 2); //shared info about database file size
+         db->dbMappedSize = db->shared->mappedDbSize; //local info about mapped size of file
+
+         writeDualDataBlock(db, endoffset, i, key, klen, value, valueSize);
+
+         //update hashtable entry
+         offset = endoffset + sizeof(DataBlock_s);
+         hashTable[hash].offsetA = endoffset; //write the offsetA to the data in the memory-hashtable slot
+         hashTable[hash].offsetB = offset;    //write the offset to the data in the memory-hashtable slot
+         hashTable[hash].current = 0x00;
+
+         *(bytesWritten) = valueSize;
+         return 0; /* success */
       }
+      hashTable = (Hashtable_slot_s*) ((char*) hashTable + sizeof(Hashtable_s));  //pointer to the next memory-hashtable
    }
-   endoffset = lseek(db->fd, 0, SEEK_CUR);
 
-   //if new size would exceed old shared memory size-> allocate additional memory to shared memory (+ db->hash_table_size_bytes)
-   if( (db->hash_table_size_bytes * (db->shmem_info->num_hash_tables + 1)) > db->shmem_info->shmem_size)
+   //if new size would exceed old shared memory size for hashtables-> allocate additional memory to shared memory (+ db->htSizeBytes)
+   if( (db->htSizeBytes * (db->shared->htNum + 1)) > db->shared->htShmSize)
    {
-      if (db->shmem_ht_fd <= 0)
+      //munlockall();
+      if (db->htFd <= 0)
       {
-         db->shmem_ht_fd = kdbShmemOpen(db->shmem_ht_name,  db->old_mapped_size, &temp);
-         if(db->shmem_ht_fd < 0)
+         db->htFd = kdbShmemOpen(db->htName,  db->htMappedSize, &temp);
+         if(db->htFd < 0)
+         {
             return KISSDB_ERROR_OPEN_SHM;
+         }
       }
-      result = resizeKdbShmem(db->shmem_ht_fd, &db->hash_tables, db->old_mapped_size, db->old_mapped_size + db->hash_table_size_bytes);
+      result = resizeKdbShmem(db->htFd, &db->hashTables, db->htMappedSize, db->htMappedSize + db->htSizeBytes);
       if (result == Kdb_false)
       {
          return KISSDB_ERROR_RESIZE_SHM;
       }
       else
       {
-         db->shmem_info->shmem_size = db->old_mapped_size + db->hash_table_size_bytes;
-         db->old_mapped_size = db->shmem_info->shmem_size;
+         db->shared->htShmSize = db->htMappedSize + db->htSizeBytes;
+         db->htMappedSize = db->shared->htShmSize;
       }
+      //mlockall(MCL_FUTURE);
    }
 
-   //if( currentHtOffset <= db->old_mapped_size / sizeof(Hashtable_slot_s) )
-   cur_hash_table = &(db->hash_tables[(db->hash_table_size + 1) * db->shmem_info->num_hash_tables]);
-   //else
-   //   return KISSDB_ERROR_ACCESS_VIOLATION;
-   memset(cur_hash_table, 0, db->hash_table_size_bytes); //hashtable init
-   cur_hash_table[hash].offsetA = endoffset + db->hash_table_size_bytes; /* where new entry will go (behind the new Ht that gets written)*/
-
-#ifdef __useBackups
-   crc = 0x00;
-   crc = (uint64_t) pcoCrc32(crc, (unsigned char*)value, db->value_size);
-   cur_hash_table[hash].checksumA = crc;
-   cur_hash_table[hash].checksumB = crc;
-   cur_hash_table[hash].offsetB = cur_hash_table[hash].offsetA + (db->key_size + db->value_size);//write the offset to the data in the memory-hashtable slot
-   cur_hash_table[hash].current = 0x00;
-#endif
-
-   // write new hashtable at the end of the file
-   if (write( db->fd, cur_hash_table, db->hash_table_size_bytes) != db->hash_table_size_bytes )
-   {
-      Kdb_unlock(&db->shmem_info->rwlock);
-      return KISSDB_ERROR_IO;
-   }
-   // write key behind new hashtable
-   if (write( db->fd, key, db->key_size) != db->key_size )
+   /* if no existing slots, add a new page of hash table entries */
+   endoffset = db->shared->mappedDbSize;
+   if ( -1 == endoffset) //filepointer to the end of the file
    {
-      Kdb_unlock(&db->shmem_info->rwlock);
       return KISSDB_ERROR_IO;
    }
-   // write value behind key
-   if (write( db->fd, value, db->value_size) != db->value_size )
+   //truncate file in order to save new hashtable + two Datablocks (this does not modify filedescriptor)
+   if (ftruncate(db->fd, endoffset + db->htSizeBytes + (sizeof(DataBlock_s) * 2)) < 0)
    {
-      Kdb_unlock(&db->shmem_info->rwlock);
       return KISSDB_ERROR_IO;
    }
-   // write same key and value again here --> initial write
-#ifdef __useBackups
-   if (write( db->fd, key, db->key_size) != db->key_size )
+
+   db->mappedDb = mremap(db->mappedDb, db->dbMappedSize, db->shared->mappedDbSize + (db->htSizeBytes + (sizeof(DataBlock_s) * 2)), MREMAP_MAYMOVE);
+   if (db->mappedDb == MAP_FAILED)
    {
-      Kdb_unlock(&db->shmem_info->rwlock);
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"),DLT_STRING(strerror(errno)));
       return KISSDB_ERROR_IO;
    }
-   if (write( db->fd, value, db->value_size) != db->value_size )
+   db->shared->mappedDbSize = db->shared->mappedDbSize + (db->htSizeBytes + (sizeof(DataBlock_s) * 2));
+   db->dbMappedSize = db->shared->mappedDbSize;
+
+   //prepare new hashtable in shared memory
+   hashtable = &(db->hashTables[db->shared->htNum]);
+   memset(hashtable, 0, db->htSizeBytes); //hashtable init
+   hashtable->delimStart = HASHTABLE_START_DELIMITER;
+   hashtable->delimEnd = HASHTABLE_END_DELIMITER;
+   hashtable->crc = 0x00;
+   hashTable = hashtable->slots; //pointer to the next memory-hashtable
+   hashTable[hash].offsetA = endoffset + db->htSizeBytes; /* where new entry will go (behind the new Ht that gets written)*/
+   hashTable[hash].offsetB = hashTable[hash].offsetA + sizeof(DataBlock_s);//write the offset to the data in the memory-hashtable slot
+   hashTable[hash].current = 0x00;
+
+   htptr = (Hashtable_s*) (db->mappedDb + endoffset);
+   //copy hashtable in shared memory to mapped hashtable in file
+   memcpy(htptr, hashtable, db->htSizeBytes);
+   //write data behind new hashtable
+   writeDualDataBlock(db, endoffset + db->htSizeBytes, db->shared->htNum, key, klen, value, valueSize);
+   //if a hashtable exists, update link to new hashtable in previous hashtable
+   if (db->shared->htNum)
    {
-      Kdb_unlock(&db->shmem_info->rwlock);
-      return KISSDB_ERROR_IO;
+      db->hashTables[db->shared->htNum -1].slots[HASHTABLE_SLOT_COUNT].offsetA = endoffset; //update link to new hashtable in previous hashtable
    }
-#endif
+   ++db->shared->htNum;
+
+   *(bytesWritten) = valueSize;
 
-   //if a hashtable exists, update link to new hashtable
-   if (db->shmem_info->num_hash_tables)
-   {
-      if (lseek(db->fd, lasthtoffset + (sizeof(Hashtable_slot_s) * db->hash_table_size), SEEK_SET) == -1)
-      {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return KISSDB_ERROR_IO;
-      }
-      if (write( db->fd, &endoffset, sizeof(int64_t)) != sizeof(int64_t) )
-      {
-         Kdb_unlock(&db->shmem_info->rwlock);
-         return KISSDB_ERROR_IO;
-      }
-      db->hash_tables[((db->hash_table_size + 1) * (db->shmem_info->num_hash_tables - 1)) + db->hash_table_size].offsetA = endoffset; //update link to new hashtable in old hashtable
-   }
-   ++db->shmem_info->num_hash_tables;
-   //fsync(db->fd)
-   Kdb_unlock(&db->shmem_info->rwlock);
    return 0; /* success */
 }
 
@@ -1242,34 +1280,25 @@ int KISSDB_put(KISSDB *db, const void *key, const void *value)
 /*
  * prints the offsets stored in the shared Hashtable
  */
-void printSharedHashtable(KISSDB *db)
+void printSharedHashtable(KISSDB* db)
 {
-   Hashtable_slot_s *cur_hash_table;
-   cur_hash_table = db->hash_tables;
-   unsigned long k;
-   unsigned long x = (db->hash_table_size * db->shmem_info->num_hash_tables);
-   //printf("Address of SHARED HT_NUMBER: %p \n", &db->shmem_info->num_hash_tables);
-   printf("Address of SHARED HEADER: %p \n", &cur_hash_table);
-   Header_s* ptr;
-   printf("HT Struct sizes: %d, %d, %d, %d,%d, %d, %d, %d\n", sizeof(ptr->KdbV), sizeof(ptr->checksum), sizeof(ptr->closeFailed), sizeof(ptr->closeOk), sizeof(ptr->hash_table_size),sizeof(ptr->key_size),sizeof(ptr->value_size),sizeof(ptr->delimiter));
-   printf("HEADER SIZE: %d \n", sizeof(Header_s));
-   printf("Hashtable_slot_s SIZE: %d \n", sizeof(Hashtable_slot_s));
-   for (k = 0; k < x; k++)
+   unsigned long k=0;
+   int i = 0;
+
+   for(i =0 ; i< db->shared->htNum; i++)
    {
-      if (db->hash_tables[k].offsetA != 0)
+      for (k = 0; k <= db->htSize; k++)
       {
-         printf("offsetA  [%lu]: %" PRId64 " \n", k, db->hash_tables[k].offsetA);
-         printf("checksumA[%lu]: %" PRIu64 " \n", k, db->hash_tables[k].checksumA);
-         printf("offsetB  [%lu]: %" PRId64 " \n", k, db->hash_tables[k].offsetB);
-         printf("checksumB[%lu]: %" PRIu64 " \n", k, db->hash_tables[k].checksumB);
-         printf("current  [%lu]: %" PRIu64 " \n", k, db->hash_tables[k].current);
+         printf("ht[%d] offsetA  [%lu]: %" PRId64 " \n",i, k, db->hashTables[i].slots[k].offsetA);
+         printf("ht[%d] offsetB  [%lu]: %" PRId64 " \n",i, k, db->hashTables[i].slots[k].offsetB);
+         printf("ht[%d] current  [%lu]: %" PRIu64 " \n",i, k, db->hashTables[i].slots[k].current);
       }
    }
 }
 #endif
 
 
-void KISSDB_Iterator_init(KISSDB *db, KISSDB_Iterator *dbi)
+void KISSDB_Iterator_init(KISSDB* db, KISSDB_Iterator* dbi)
 {
    dbi->db = db;
    dbi->h_no = 0;  // number of read hashtables
@@ -1277,235 +1306,953 @@ void KISSDB_Iterator_init(KISSDB *db, KISSDB_Iterator *dbi)
 }
 
 
-int KISSDB_Iterator_next(KISSDB_Iterator *dbi, void *kbuf, void *vbuf)
+int KISSDB_Iterator_next(KISSDB_Iterator* dbi, void* kbuf, void* vbuf)
 {
+   DataBlock_s* block;
+   Hashtable_slot_s* ht;
    int64_t offset;
-   Kdb_rdlock(&dbi->db->shmem_info->rwlock);
 
-   if ((dbi->h_no < (dbi->db->shmem_info->num_hash_tables)) && (dbi->h_idx < dbi->db->hash_table_size))
+   if(dbi->db->htMappedSize < dbi->db->shared->htShmSize)
+   {
+      if ( Kdb_false == remapSharedHashtable(dbi->db->htFd, &dbi->db->hashTables, dbi->db->htMappedSize, dbi->db->shared->htShmSize))
+      {
+         return KISSDB_ERROR_RESIZE_SHM;
+      }
+      else
+      {
+         dbi->db->htMappedSize = dbi->db->shared->htShmSize;
+      }
+   }
+
+   //remap database file if in the meanwhile another process added new data (key value pairs / hashtables) to the file
+   if (dbi->db->dbMappedSize < dbi->db->shared->mappedDbSize)
+   {
+      dbi->db->mappedDb = mremap(dbi->db->mappedDb, dbi->db->dbMappedSize, dbi->db->shared->mappedDbSize, MREMAP_MAYMOVE);
+      if (dbi->db->mappedDb == MAP_FAILED)
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(":mremap error: !"), DLT_STRING(strerror(errno)));
+         return KISSDB_ERROR_IO;
+      }
+      dbi->db->dbMappedSize = dbi->db->shared->mappedDbSize;
+   }
+
+   if ((dbi->h_no < (dbi->db->shared->htNum)) && (dbi->h_idx < dbi->db->htSize))
    {
-      //TODO check for currently valid data block flag and use this offset instead of offsetA
-      while (!(offset = dbi->db->hash_tables[((dbi->db->hash_table_size + 1) * dbi->h_no) + dbi->h_idx].offsetA))
+      ht = dbi->db->hashTables[dbi->h_no].slots; //pointer to first hashtable
+
+      while ( !(ht[dbi->h_idx].offsetA || ht[dbi->h_idx].offsetB) ) //until a offset was found
       {
-         if (++dbi->h_idx >= dbi->db->hash_table_size)
+         if (++dbi->h_idx >= dbi->db->htSize)
          {
             dbi->h_idx = 0;
-            if (++dbi->h_no >= (dbi->db->shmem_info->num_hash_tables))
+            if (++dbi->h_no >= (dbi->db->shared->htNum))
             {
-               Kdb_unlock(&dbi->db->shmem_info->rwlock);
                return 0;
             }
+            else
+            {
+               ht = dbi->db->hashTables[dbi->h_no].slots;   //next hashtable
+            }
          }
       }
-
-      if (lseek(dbi->db->fd, offset, SEEK_SET) == -1)
-         return KISSDB_ERROR_IO;
-      if (read(dbi->db->fd, kbuf, dbi->db->key_size) != dbi->db->key_size)
-         return KISSDB_ERROR_IO;
-      if (vbuf != NULL)
+      if(ht[dbi->h_idx].current == 0x00)
       {
-         if (read(dbi->db->fd, vbuf, dbi->db->value_size) != dbi->db->value_size)
-            return KISSDB_ERROR_IO;
+         offset = ht[dbi->h_idx].offsetA;
       }
       else
       {
-         if (lseek(dbi->db->fd, dbi->db->value_size, SEEK_CUR) == -1)
-            return KISSDB_ERROR_IO;
+         offset = ht[dbi->h_idx].offsetB;
+      }
+
+      if( abs(offset) > dbi->db->dbMappedSize )
+      {
+         return KISSDB_ERROR_IO;
       }
 
-      if (++dbi->h_idx >= dbi->db->hash_table_size)
+      block = (DataBlock_s*) (dbi->db->mappedDb + offset);
+      memcpy(kbuf,block->key, dbi->db->keySize);
+      if (vbuf != NULL)
+      {
+         memcpy(vbuf, block->value, dbi->db->valSize);
+      }
+      if (++dbi->h_idx >= dbi->db->htSize)
       {
          dbi->h_idx = 0;
          ++dbi->h_no;
       }
-      Kdb_unlock(&dbi->db->shmem_info->rwlock);
       return 1;
    }
-   Kdb_unlock(&dbi->db->shmem_info->rwlock);
    return 0;
 }
 
 
 
-int readHeader(KISSDB* db, uint16_t* hash_table_size, uint64_t* key_size, uint64_t* value_size)
+
+int readHeader(KISSDB* db, uint16_t* htSize, uint64_t* keySize, uint64_t* valSize)
 {
-   //set Filepointer to the beginning of the file
-   if (lseek(db->fd, 0, SEEK_SET) == -1)
-      return KISSDB_ERROR_IO;
-   //mmap header from beginning of file
-   int mapFlag = PROT_WRITE | PROT_READ;
    Header_s* ptr = 0;
-   ptr = (Header_s*) mmap(NULL, KISSDB_HEADER_SIZE, mapFlag, MAP_SHARED, db->fd, 0);
-   if (ptr == MAP_FAILED)
-      return KISSDB_ERROR_IO;
+   ptr = (Header_s*) db->mappedDb;
 
-   if ((ptr->KdbV[0] != 'K') || (ptr->KdbV[1] != 'd') || (ptr->KdbV[2] != 'B') || (ptr->KdbV[3] != KISSDB_VERSION))
+   if ((ptr->KdbV[0] != 'K') || (ptr->KdbV[1] != 'd') || (ptr->KdbV[2] != 'B') )
+   {
       return KISSDB_ERROR_CORRUPT_DBFILE;
-
-   if (!ptr->hash_table_size)
+   }
+   if( (ptr->KdbV[3] != KISSDB_MAJOR_VERSION) || (ptr->KdbV[4] != '.') || (ptr->KdbV[5] != KISSDB_MINOR_VERSION))
+   {
+      return KISSDB_ERROR_WRONG_DATABASE_VERSION;
+   }
+   if (!ptr->htSize)
+   {
       return KISSDB_ERROR_CORRUPT_DBFILE;
-   (*hash_table_size) = (uint16_t) ptr->hash_table_size;
-
-   if (!ptr->key_size)
+   }
+   (*htSize) = (uint16_t) ptr->htSize;
+   if (!ptr->keySize)
+   {
       return KISSDB_ERROR_CORRUPT_DBFILE;
-   (*key_size) = (uint64_t) ptr->key_size;
+   }
+   (*keySize) = (uint64_t) ptr->keySize;
 
-   if (!ptr->value_size)
+   if (!ptr->valSize)
+   {
       return KISSDB_ERROR_CORRUPT_DBFILE;
-   (*value_size) = (uint64_t) ptr->value_size;
-
-   //sync changes with file
-   if (0 != msync(ptr, KISSDB_HEADER_SIZE, MS_SYNC | MS_INVALIDATE))
-      return KISSDB_ERROR_IO;
-
-   //unmap memory
-   if (0 != munmap(ptr, KISSDB_HEADER_SIZE))
-      return KISSDB_ERROR_IO;
+   }
+   (*valSize) = (uint64_t) ptr->valSize;
    return 0;
 }
 
 
 
 
-int writeHeader(KISSDB* db, uint16_t* hash_table_size, uint64_t* key_size, uint64_t* value_size)
+int writeHeader(KISSDB* db, uint16_t* htSize, uint64_t* keySize, uint64_t* valSize)
 {
    Header_s* ptr = 0;
    int ret= 0;
 
-   //Seek to beginning of file
-   if (lseek(db->fd, 0, SEEK_SET) == -1)
-      return KISSDB_ERROR_IO;
-
-   //ftruncate file to needed size for header
+   //truncate file to needed size for header
    ret = ftruncate(db->fd, KISSDB_HEADER_SIZE);
    if (ret < 0)
+   {
       return KISSDB_ERROR_IO;
-
-   //mmap header from beginning of file
-   int mapFlag = PROT_WRITE | PROT_READ;
-   ptr = (Header_s*) mmap(NULL, KISSDB_HEADER_SIZE, mapFlag, MAP_SHARED, db->fd, 0);
-   if (ptr == MAP_FAILED)
+   }
+   //mmap whole file for the first time
+   db->mappedDb = (void*) mmap(NULL, KISSDB_HEADER_SIZE, PROT_WRITE | PROT_READ, MAP_SHARED, db->fd, 0);
+   if (db->mappedDb == MAP_FAILED)
+   {
       return KISSDB_ERROR_IO;
+   }
+   db->shared->mappedDbSize = KISSDB_HEADER_SIZE;
+   db->dbMappedSize = KISSDB_HEADER_SIZE;
 
+   ptr = (Header_s*) db->mappedDb;
    ptr->KdbV[0] = 'K';
    ptr->KdbV[1] = 'd';
    ptr->KdbV[2] = 'B';
-   ptr->KdbV[3] = KISSDB_VERSION;
-   ptr->KdbV[4] = '-';
-   ptr->KdbV[5] = '-';
-   ptr->KdbV[6] = '-';
-   ptr->KdbV[7] = '-';
+   ptr->KdbV[3] = KISSDB_MAJOR_VERSION;
+   ptr->KdbV[4] = '.';
+   ptr->KdbV[5] = KISSDB_MINOR_VERSION;
+   ptr->KdbV[6] = '0';
+   ptr->KdbV[7] = '0';
    ptr->checksum = 0x00;
    ptr->closeFailed = 0x00; //remove closeFailed flag
    ptr->closeOk = 0x01;     //set closeOk flag
-   ptr->hash_table_size = (uint64_t)(*hash_table_size);
-   ptr->key_size = (uint64_t)(*key_size);
-   ptr->value_size = (uint64_t)(*value_size);
-   memcpy(ptr->delimiter,"||||||||", 8);
-
-   //sync changes with file
-   if (0 != msync(ptr, KISSDB_HEADER_SIZE, MS_SYNC | MS_INVALIDATE))
-      return KISSDB_ERROR_IO;
+   ptr->htSize = (uint64_t)(*htSize);
+   ptr->keySize = (uint64_t)(*keySize);
+   ptr->valSize = (uint64_t)(*valSize);
+   msync(db->mappedDb, KISSDB_HEADER_SIZE, MS_SYNC);
 
-   //unmap memory
-   if (0 != munmap(ptr, KISSDB_HEADER_SIZE))
-      return KISSDB_ERROR_IO;
    return 0;
 }
 
 
 int checkErrorFlags(KISSDB* db)
 {
-   //mmap header from beginning of file
-   int mapFlag = PROT_WRITE | PROT_READ;
-   Header_s* ptr = 0;
-   ptr = (Header_s*) mmap(NULL, KISSDB_HEADER_SIZE, mapFlag, MAP_SHARED, db->fd, 0);
-   if (ptr == MAP_FAILED)
-      return KISSDB_ERROR_IO;
-   //uint64_t crc = 0;
+   Header_s* ptr;
+   ptr = (Header_s*) db->mappedDb;
 
-#ifdef __checkerror
-   //check if closeFailed flag is set
-   if(ptr->closeFailed == 0x01)
+   //check if closeFailed flag is set or closeOk is not set
+   if(ptr->closeFailed == 0x01 || ptr->closeOk == 0x00 )
    {
-      //TODO implement verifyHashtableCS
+#ifdef PFS_TEST
+      printf("CHECK ERROR FLAGS: CLOSE FAILED!\n");
+#endif
+      ptr->closeFailed = 0x01; //create close failed flags
+      ptr->closeOk = 0x00;
+      return KISSDB_ERROR_CORRUPT_DBFILE;
+   }
+   else
+   {
+#ifdef PFS_TEST
+      printf("CHECK ERROR FLAGS: CLOSE OK!\n");
+#endif
+      ptr->closeFailed = 0x01; //NO: create close failed flag
+      ptr->closeOk = 0x00;
+   }
+   msync(db->mappedDb, KISSDB_HEADER_SIZE, MS_SYNC);
 
-      //if closeFailed flag is set, something went wrong at last close -> so check crc
-      db->shmem_info->crc_invalid = Kdb_true; //check crc for further reads
+   return 0;
+}
 
-#if 0
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING("OPENING DB -> closeFailed flag is set:  "), DLT_UINT64(ptr->closeFailed));
-      crc = (uint64_t) pcoCalcCrc32Csum(db->fd, sizeof(Header_s));
-      if(ptr->checksum != 0) //do not check if database is currently in creation
+
+int verifyHashtableCS(KISSDB* db)
+{
+   char* ptr;
+   Hashtable_s* hashtable;
+   int i = 0;
+   int ptrOffset=1;
+   int64_t offset = 0;
+   struct stat statBuf;
+   uint64_t crc = 0;
+   void* memory;
+
+   if (db->fd)
+   {
+      //map entire file into memory
+      fstat(db->fd, &statBuf);
+      memory = (void*) mmap(NULL, statBuf.st_size, PROT_WRITE | PROT_READ, MAP_SHARED, db->fd, 0);
+      if (memory == MAP_FAILED)
+      {
+         return KISSDB_ERROR_IO;
+      }
+      ptr = (char*) memory;
+      db->shared->htNum = 0;
+      //unmap previously allocated and maybe corrupted hashtables
+      munmap(db->hashTables, db->htMappedSize);
+      db->hashTables = (Hashtable_s*) getKdbShmemPtr(db->htFd, db->htSizeBytes);
+      if(db->hashTables == ((void*) -1))
+      {
+         return KISSDB_ERROR_MAP_SHM;
+      }
+      db->htMappedSize = db->htSizeBytes; //size for first hashtable
+
+      //determine greatest common factor of hashtable and datablock used for pointer incrementation
+      ptrOffset = greatestCommonFactor(sizeof(DataBlock_s), sizeof(Hashtable_s) );
+
+      //offsets in mapped area to first hashtable
+      offset = sizeof(Header_s);
+      ptr += offset;
+
+      //get number of hashtables in file (search for hashtable delimiters) and copy the hashtables to memory
+      while (offset <= (statBuf.st_size - db->htSizeBytes)) //begin with offset for first hashtable
       {
-         if (crc != ptr->checksum)
+         hashtable = (Hashtable_s*) ptr;
+         //if at least one of two hashtable delimiters are found
+         if (hashtable->delimStart == HASHTABLE_START_DELIMITER
+               || hashtable->delimEnd == HASHTABLE_END_DELIMITER)
          {
-            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING("OPENING DB: "), DLT_STRING(db->shmem_ht_name), DLT_STRING(" CHECKSUM IN HEADER : "), DLT_UINT64(ptr->checksum), DLT_STRING(" != CHECKSUM CALCULATED: "), DLT_UINT64(crc));
-            //db->shmem_info->crc_invalid = Kdb_true; //check datablocks at further reads
-            //return KISSDB_ERROR_CORRUPT_DBFILE; //previous close failed and checksum invalid -> error state -> return error
+               //next hashtable to use
+               //rewrite delimiters to make sure that both exist
+               hashtable->delimStart = HASHTABLE_START_DELIMITER;
+               hashtable->delimEnd   = HASHTABLE_END_DELIMITER;
+               Kdb_bool result = Kdb_false;
+               //if new size would exceed old shared memory size-> allocate additional memory page to shared memory
+               if (db->htSizeBytes * (db->shared->htNum + 1) > db->htMappedSize)
+               {
+                  result = resizeKdbShmem(db->htFd, &db->hashTables, db->htMappedSize, db->htMappedSize + db->htSizeBytes);
+                  if (result == Kdb_false)
+                  {
+                     return KISSDB_ERROR_RESIZE_SHM;
+                  }
+                  else
+                  {
+                     db->shared->htShmSize = db->htMappedSize + db->htSizeBytes;
+                     db->htMappedSize = db->shared->htShmSize;
+                  }
+               }
+               // copy the current hashtable read from file to (htadress + (htsize  * htcount)) in memory
+               memcpy(((uint8_t*) db->hashTables) + (db->htSizeBytes * db->shared->htNum), ptr, db->htSizeBytes);
+               ++db->shared->htNum;
+
+               //jump to next data block after hashtable
+               offset += sizeof(Hashtable_s);
+               ptr += sizeof(Hashtable_s);
          }
          else
          {
-            DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("OPENING DB: "), DLT_STRING(db->shmem_ht_name), DLT_STRING(" CECHKSUM IN HEADER: "), DLT_UINT64(ptr->checksum), DLT_STRING(" == CHECKSUM CALCULATED: "), DLT_UINT64(crc));
-            //db->shmem_info->crc_invalid = Kdb_false; //do not check datablocks at further reads
+            offset += ptrOffset;
+            ptr += ptrOffset;
          }
       }
-      else
-         DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("Do not check checksum, database in creation: "), DLT_STRING(db->shmem_ht_name));
+      munmap(memory, statBuf.st_size);
+
+      //check CRC of all found hashtables
+      if (db->shared->htNum > 0)
+      {
+         for (i = 0; i < db->shared->htNum; i++)
+         {
+            crc = 0;
+            crc = (uint64_t) pcoCrc32(crc, (unsigned char*) db->hashTables[i].slots, sizeof(db->hashTables[i].slots));
+            if (db->hashTables[i].crc != crc)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(": Checksum of hashtable number: <"); DLT_INT(i); DLT_STRING("> is invalid"));
+#ifdef PFS_TEST
+               printf("VERIFY HASHTABLE: hashtable #%d: CHECKSUM INVALID! \n",i);
 #endif
+               return -1; //start rebuild of hashtables
+            }
+            else
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(__FUNCTION__); DLT_STRING(": Checksum of hashtable number: <"); DLT_INT(i); DLT_STRING("> is OK"));
+
+#ifdef PFS_TEST
+               printf("VERIFY HASHTABLE: hashtable #%d: CHECKSUM OK! \n",i);
+#endif
+            }
+         }
+      }
    }
-   else
+   return 0;
+}
+
+int rebuildHashtables(KISSDB* db)
+{
+   char* ptr;
+   DataBlock_s* data;
+   DataBlock_s* dataA;
+   DataBlock_s* dataB;
+   Hashtable_s* hashtable;
+   int current = 0;
+   int ptrOffset = 1;
+   int64_t offset=0;
+   int64_t offsetA = 0;
+   struct stat statBuf;
+   uint64_t crc = 0;
+   uint64_t calcCrcA, calcCrcB, readCrcA, readCrcB;
+   void* memory;
+
+   fstat(db->fd, &statBuf);
+   memory = (char*) mmap(NULL, statBuf.st_size, PROT_WRITE | PROT_READ, MAP_SHARED, db->fd, 0);
+   if (memory == MAP_FAILED)
    {
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("OPENING DB: closeFailed flag is not set:  "), DLT_UINT64(ptr->closeFailed));
-      ptr->closeFailed = 0x01; //NO: create close failed flag
+      return KISSDB_ERROR_IO;
    }
+   ptr = (char*) memory;
+
+   //recover all hashtables of database
+   if (db->shared->htNum > 0) //htNum was determined in verifyhashtables() -> no reallocation is needed
+   {
+      ptr = (void*) memory;
+      memset(db->hashTables, 0, db->shared->htNum * sizeof(Hashtable_s));
+      db->hashTables[0].delimStart = HASHTABLE_START_DELIMITER;
+      db->hashTables[0].delimEnd = HASHTABLE_END_DELIMITER;
+
+      ptrOffset = greatestCommonFactor(sizeof(DataBlock_s), sizeof(Hashtable_s) );
+
+      //begin searching after first hashtable
+      offset = sizeof(Header_s) + sizeof(Hashtable_s);
+      ptr += offset;
 
+      //go through  database file until offset + Datablock size reaches end of file mapping
+      while (offset <= (statBuf.st_size - sizeof(DataBlock_s)))
+      {
+         data = (DataBlock_s*) ptr;
 
-   //check if closeOk flag is set
-   if(ptr->closeOk == 0x01)
+         //if block A start or end delimiters were found
+         if (data->delimStart == DATA_BLOCK_A_START_DELIMITER
+               || data->delimEnd == DATA_BLOCK_A_END_DELIMITER)
+         {
+            //calculate checksum of Block A
+            calcCrcA = 0;
+            calcCrcA = (uint64_t) pcoCrc32(calcCrcA, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+            readCrcA = data->crc;
+
+            //search for block B start delimiter
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+            dataB = (DataBlock_s*) ptr;
+            if (dataB->delimStart == DATA_BLOCK_B_START_DELIMITER
+                  || dataB->delimEnd == DATA_BLOCK_B_END_DELIMITER)
+            {
+               //verify checksum of Block B
+               calcCrcB = 0;
+               calcCrcB = (uint64_t) pcoCrc32(calcCrcB, (unsigned char*) dataB->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+               readCrcB = dataB->crc;
+               if (readCrcB == calcCrcB) //checksum of block B matches
+               {
+                  if (readCrcA == calcCrcA) //checksum of block A matches
+                  {
+                     if (1) //decide which datablock has latest written data - still statically using Block B for recovery because both blocks are written in kissdb_put
+                     {
+                        offsetA = offset - sizeof(DataBlock_s);
+                        rebuildWithBlockB(dataB, db, offsetA, offset);
+                     }
+                     else
+                     {
+                        // use block A for rebuild
+                        //write offsets for block a and block B
+                        offsetA = offset - sizeof(DataBlock_s);
+                        rebuildWithBlockA(data, db, offsetA, offset);
+                     }
+                  }
+                  else //checksum of block A does not match, but checksum of block B was valid
+                  {
+                     // use block B for rebuild
+                     offsetA = offset - sizeof(DataBlock_s);
+                     rebuildWithBlockB(dataB, db, offsetA, offset);
+                  }
+               }
+               else
+               {
+                  if (readCrcA == calcCrcA)
+                  {
+                     // use block A for rebuild
+                     //write offsets for block a and block B
+                     offsetA = offset - sizeof(DataBlock_s);
+                     rebuildWithBlockA(data, db, offsetA, offset);
+                  }
+                  else //checksum of block A and of Block B do not match ---> worst case scenario
+                  {
+                     invalidateBlocks(data, dataB, db);
+                  }
+               }
+            }
+            else
+            {
+               //if checksum A matches and block B was not found
+               if (readCrcA == calcCrcA)
+               {
+                  // use block A for rebuild
+                  //write offsets for block a and block B
+                  offsetA = offset - sizeof(DataBlock_s);
+                  rebuildWithBlockA(data, db, offsetA, offset);
+               }
+               else //checksum of block A does not match and block B was not found
+               {
+                  invalidateBlocks(data, dataB, db);
+               }
+            }
+            //jump behind datablock B
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+         }
+         //If a Bock B start or end delimiters were found: this only can happen if previous Block A was not found
+         else if (data->delimStart == DATA_BLOCK_B_START_DELIMITER
+                    || data->delimEnd == DATA_BLOCK_B_END_DELIMITER)
+         {
+            dataA = (DataBlock_s*) (ptr - sizeof(DataBlock_s)) ;
+            //verify checksum of Block B
+            crc = 0;
+            crc = (uint64_t) pcoCrc32(crc, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+            if (data->crc == crc)
+            {
+               //use block B for rebuild
+               //write offsets for block A and block B
+               offsetA = offset - sizeof(DataBlock_s);
+               rebuildWithBlockB(data, db, offsetA, offset);
+            }
+            else
+            {
+               invalidateBlocks(dataA, data, db);
+            }
+            //jump behind datablock B
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+         }
+         else if (data->delimStart == DATA_BLOCK_A_DELETED_START_DELIMITER
+                    || data->delimEnd == DATA_BLOCK_A_DELETED_END_DELIMITER)
+         {
+            //calculate checksum of Block A
+            calcCrcA = 0;
+            calcCrcA = (uint64_t) pcoCrc32(calcCrcA, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+            readCrcA = data->crc;
+
+            //search for block B start delimiter
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+            dataB = (DataBlock_s*) ptr;
+
+            if (dataB->delimStart == DATA_BLOCK_B_DELETED_START_DELIMITER
+                  || dataB->delimEnd == DATA_BLOCK_B_DELETED_END_DELIMITER)
+            {
+               //calculate checksum of Block B
+               calcCrcB = 0;
+               calcCrcB = (uint64_t) pcoCrc32(calcCrcB, (unsigned char*) dataB->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+               readCrcB = dataB->crc;
+               if (readCrcB == calcCrcB) //checksum of block B matches
+               {
+                  offsetA = offset - sizeof(DataBlock_s);
+                  invertBlockOffsets(data, db, offsetA, offset);
+               }
+               else
+               {
+                  if (readCrcA == calcCrcA)
+                  {
+                     offsetA = offset - sizeof(DataBlock_s);
+                     invertBlockOffsets(data, db, offsetA, offset);
+                  }
+                  else
+                  {
+                     invalidateBlocks(data, dataB, db);
+                  }
+               }
+            }
+            else //NO BLOCK B Found
+            {
+               if (readCrcA == calcCrcA)
+               {
+
+                  offsetA = offset - sizeof(DataBlock_s);
+                  invertBlockOffsets(data, db, offsetA, offset);
+               }
+               else
+               {
+                  invalidateBlocks(data, dataB, db);
+               }
+            }
+            //jump behind datablock B
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+         }
+         else if (data->delimStart == DATA_BLOCK_B_DELETED_START_DELIMITER
+                    || data->delimEnd == DATA_BLOCK_B_DELETED_END_DELIMITER)
+         {
+            crc = 0;
+            crc = (uint64_t) pcoCrc32(crc, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+            if (crc == data->crc)
+            {
+               offsetA = offset - sizeof(DataBlock_s);
+               invertBlockOffsets(data, db, offsetA, offset);
+            }
+            else
+            {
+               dataA = (DataBlock_s*) (ptr - sizeof(DataBlock_s)) ;
+               invalidateBlocks(dataA, data, db);
+            }
+            //jump behind datablock B
+            offset += sizeof(DataBlock_s);
+            ptr += sizeof(DataBlock_s);
+         }
+         else if( offset <= (statBuf.st_size - sizeof(Hashtable_s)) ) //check if ptr range for hashtable is within mapping of file
+         {
+            hashtable = (Hashtable_s*) ptr;
+
+            if (hashtable->delimStart == HASHTABLE_START_DELIMITER
+                  || hashtable->delimEnd == HASHTABLE_END_DELIMITER)
+            {
+               //next hashtable to use
+               db->hashTables[current].slots[db->htSize].offsetA = offset; //update link to next hashtable in current hashtable
+               current++;
+               if (current < db->shared->htNum)
+               {
+                  db->hashTables[current].delimStart = HASHTABLE_START_DELIMITER;
+                  db->hashTables[current].delimEnd   = HASHTABLE_END_DELIMITER;
+               }
+               else
+               {
+                  return -1;
+               }
+               offset += sizeof(Hashtable_s);
+               ptr += sizeof(Hashtable_s);
+            }
+            else //if no hashtable is found
+            {
+               offset += ptrOffset;
+               ptr += ptrOffset;
+            }
+         }
+         else //if nothing is found for offsets in -> (filesize - hashtablesize)   area
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(": No Datablock or hashtable area found!"));
+            //increment pointer by greatest common factor of hashtable size and datablock size
+            offset += ptrOffset;
+            ptr += ptrOffset;
+         }
+      }
+   }
+   msync(memory, statBuf.st_size, MS_SYNC | MS_INVALIDATE);
+   munmap(memory, statBuf.st_size);
+   return 0;
+}
+
+
+//invalidate block content for A and B
+//this block can never be found / overwritten again
+//new insertions can reuse hashtable entry but block is added at EOF
+void invalidateBlocks(DataBlock_s* dataA, DataBlock_s* dataB, KISSDB* db)
+{
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": Datablock recovery for key: <"); DLT_STRING(dataA->key); DLT_STRING("> impossible: both datablocks are invalid!"));
+
+   memset(dataA->key, 0, db->keySize);
+   memset(dataA->value, 0, db->valSize);
+   dataA->crc=0;
+   dataA->htNum = 0;
+   dataA->valSize = 0;
+
+   memset(dataB->key, 0, db->keySize);
+   memset(dataB->value, 0, db->valSize);
+   dataB->crc=0;
+   dataB->htNum = 0;
+   dataB->valSize = 0;
+}
+
+
+void invertBlockOffsets(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB)
+{
+   uint64_t hash = 0;
+   hash = KISSDB_hash(data->key, strlen(data->key)) % (uint64_t) db->htSize;
+   //invert offsets for deleted block A
+   db->hashTables[data->htNum].slots[hash].offsetA = - offsetA;
+   //invert offsets for deleted block B
+   db->hashTables[data->htNum].slots[hash].offsetB = - offsetB;
+   //reset current flag
+   db->hashTables[data->htNum].slots[hash].current = 0x00;
+}
+
+
+void rebuildWithBlockB(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB)
+{
+   uint64_t hash = KISSDB_hash(data->key, strlen(data->key)) % (uint64_t) db->htSize;
+   //write offsets for block A and block B
+   db->hashTables[data->htNum].slots[hash].offsetA = offsetA;
+   db->hashTables[data->htNum].slots[hash].offsetB = offsetB;
+   //set block B as current
+   db->hashTables[data->htNum].slots[hash].current = 0x01;
+
+   /*
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(__FUNCTION__); DLT_STRING(": Rebuild in hashtable No. <"); DLT_INT(data->htNum);
+         DLT_STRING("> with Datablock B for key: <"); DLT_STRING(data->key); DLT_STRING("- hash: <"); DLT_INT(hash); DLT_STRING("> - OffsetA: <"); DLT_INT(offsetA);
+         DLT_STRING("> - OffsetB: <"); DLT_INT(offsetB));
+   */
+}
+
+
+void rebuildWithBlockA(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB)
+{
+   uint64_t hash = KISSDB_hash(data->key, strlen(data->key)) % (uint64_t) db->htSize;
+   //write offsets for block A and block B
+   db->hashTables[data->htNum].slots[hash].offsetA = offsetA;
+   db->hashTables[data->htNum].slots[hash].offsetB = offsetB;
+   //set block B as current
+   db->hashTables[data->htNum].slots[hash].current = 0x00;
+
+   /*
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(__FUNCTION__); DLT_STRING(": Rebuild in hashtable No. <"); DLT_INT(data->htNum);
+         DLT_STRING("> with Datablock A for key: <"); DLT_STRING(data->key); DLT_STRING("- hash: <"); DLT_INT(hash); DLT_STRING("> - OffsetA: <"); DLT_INT(offsetA);
+         DLT_STRING("> - OffsetB: <"); DLT_INT(offsetB));
+   */
+}
+
+
+
+
+int recoverDataBlocks(KISSDB* db)
+{
+
+#ifdef PFS_TEST
+                  printf("DATABLOCK RECOVERY: START! \n");
+#endif
+
+   char* ptr;
+   DataBlock_s* data;
+   int i = 0;
+   int k = 0;
+   int64_t offset = 0;
+   struct stat statBuf;
+   uint64_t crc = 0;
+   void* memory;
+
+   fstat(db->fd, &statBuf);
+   memory = (char*) mmap(NULL, statBuf.st_size, PROT_WRITE | PROT_READ, MAP_SHARED, db->fd, 0);
+   if (memory == MAP_FAILED)
    {
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("OPENING DB -> closeOk flag is set:  "), DLT_UINT64(ptr->closeOk));
-      ptr->closeOk = 0x00;
+      return KISSDB_ERROR_IO;
    }
-   else
+   ptr = (char*) memory;
+
+   //go through all hashtables and jump to data blocks for crc validation
+   if (db->shared->htNum > 0)
    {
-      //if closeOK is not set , something went wrong at last close
-      db->shmem_info->crc_invalid = Kdb_true; //do crc check at read
+      ptr = (void*) memory;
+      for (i = 0; i < db->shared->htNum; i++)
+      {
+         for (k = 0; k < HASHTABLE_SLOT_COUNT; k++)
+         {
+            if (db->hashTables[i].slots[k].offsetA > 0) //ignore deleted or unused slots
+            {
+               ptr = (void*) memory;  //reset pointer
+               //current valid data is offset A or offset B?
+               offset = (db->hashTables[i].slots[k].current == 0x00) ? db->hashTables[i].slots[k].offsetA : db->hashTables[i].slots[k].offsetB;
+               ptr += offset; //set pointer to current valid datablock
+               data = (DataBlock_s*) ptr;
+               //check crc of data block marked as current in hashtable
+               crc = 0;
+               crc = (uint64_t) pcoCrc32(crc, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+               if (data->crc != crc)
+               {
+                  DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING(__FUNCTION__); DLT_STRING(": Invalid datablock found at file offset: "); DLT_INT(offset));
+#ifdef PFS_TEST
+                  printf("DATABLOCK RECOVERY: INVALID CRC FOR CURRENT DATABLOCK DETECTED! \n");
+#endif
+                  ptr = (void*) memory;
+                  //get offset to other data block and check crc
+                  offset = (db->hashTables[i].slots[k].current == 0x00) ? db->hashTables[i].slots[k].offsetB : db->hashTables[i].slots[k].offsetA;
+                  ptr += offset;
+                  data = (DataBlock_s*) ptr;
+                  crc = 0;
+                  crc = (uint64_t) pcoCrc32(crc, (unsigned char*) data->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t));
+                  if (data->crc == crc)
+                  {
+                     //switch current flag if valid backup is available
+                     db->hashTables[i].slots[k].current = (db->hashTables[i].slots[k].current == 0x00) ? 0x01 : 0x00;
+#ifdef PFS_TEST
+                     printf("DATABLOCK RECOVERY: REPAIR OF INVALID DATA SUCCESSFUL! \n");
+#endif
+                     DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(__FUNCTION__); DLT_STRING(": Invalid datablock for key: <"); DLT_STRING(data->key); DLT_STRING("> successfully recovered!"));
+                  }
+                  else
+                  {
+                     //invalidate data blocks if recovery fails
+                     db->hashTables[i].slots[k].offsetA = - db->hashTables[i].slots[k].offsetA;
+                     db->hashTables[i].slots[k].offsetB = - db->hashTables[i].slots[k].offsetB;
+                     db->hashTables[i].slots[k].current = 0x00;
+                     DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": Datablock recovery for key: <"); DLT_STRING(data->key); DLT_STRING("> impossible: both datablocks are invalid!"));
+#ifdef PFS_TEST
+                     printf("DATABLOCK RECOVERY: ERROR -> BOTH BLOCKS ARE INVALID! \n");
+#endif
+                  }
+               }
+            }
+         }
+      }
+   }
+   msync(memory, statBuf.st_size, MS_SYNC | MS_INVALIDATE);
+   munmap(memory, statBuf.st_size);
 
-#if 0
-      crc = (uint64_t) pcoCalcCrc32Csum(db->fd, sizeof(Header_s));
-      if(ptr->checksum != 0) //do not check if database is currently in creation
+#ifdef PFS_TEST
+                  printf("DATABLOCK RECOVERY: END! \n");
+#endif
+
+   return 0;
+}
+
+
+int checkIsLink(const char* path, char* linkBuffer)
+{
+   char fileName[64] = { 0 };
+   char truncPath[128] = { 0 };
+   int isLink = 0;
+   int len = 0;
+   size_t strLen = 0;
+   struct stat statBuf;
+   uint16_t i = 0;
+
+   memset(&statBuf, 0, sizeof(statBuf));
+   strLen = strlen(path);
+   for (i = 0; i < strLen; i++)
+   {
+      if (path[i] == '/')
+      {
+         len = i; // remember the position of the last '/'
+      }
+   }
+   strncpy(truncPath, path, len);
+   truncPath[len + 1] = '\0'; // set end of string
+   strncpy(fileName, (const char*) path + len, 64);
+
+   if (lstat(truncPath, &statBuf) != -1)
+   {
+      if (S_ISLNK(statBuf.st_mode))
       {
-         if (crc != ptr->checksum)
+         if (readlink(truncPath, linkBuffer, 256) != -1)
          {
-            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING("OPENING DB: "), DLT_STRING(db->shmem_ht_name), DLT_STRING(" CHECKSUM IN HEADER : "), DLT_UINT64(ptr->checksum), DLT_STRING(" != CHECKSUM CALCULATED: "), DLT_UINT64(crc));
-            //db->shmem_info->crc_invalid = Kdb_true;
-            //return KISSDB_ERROR_CORRUPT_DBFILE; //previous close failed and checksum invalid -> error state -> return error
+            strncat(linkBuffer, fileName, 256);
+            isLink = 1;
          }
          else
          {
-            DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("OPENING DB: "), DLT_STRING(db->shmem_ht_name), DLT_STRING(" CECHKSUM IN HEADER: "), DLT_UINT64(ptr->checksum), DLT_STRING(" == CHECKSUM CALCULATED: "), DLT_UINT64(crc));
-            //db->shmem_info->crc_invalid = Kdb_false;
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+                    DLT_STRING(__FUNCTION__); DLT_STRING(": readlink failed: "); DLT_STRING(strerror(errno)));
+            isLink = -1;
          }
       }
       else
       {
-         DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO, DLT_STRING("Do not check checksum, database in creation: "), DLT_STRING(db->shmem_ht_name));
+         isLink = -1;
       }
+   }
+   else
+   {
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
+              DLT_STRING(__FUNCTION__); DLT_STRING(": lstat failed: "); DLT_STRING(strerror(errno)));
+      isLink = -1;
+   }
+   return isLink;
+}
 
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN, DLT_STRING("OPENING DB -> closeOk flag is not set:  "), DLT_UINT64(ptr->closeOk));
-#endif
 
 
+void cleanKdbStruct(KISSDB* db)
+{
+   if (db->shared != NULL)
+   {
+      //Clean for every instance
+      if (db->mappedDb != NULL)
+      {
+         munmap(db->mappedDb, db->dbMappedSize);
+         db->mappedDb = NULL;
+      }
+      if (db->hashTables != NULL)
+      {
+         munmap(db->hashTables, db->htMappedSize);
+         db->hashTables = NULL;
+      }
+      if(db->cacheName != NULL)
+      {
+         free(db->cacheName);
+         db->cacheName = NULL;
+      }
+      if (db->fd)
+      {
+         close(db->fd);
+         db->fd = 0;
+      }
+      if(db->sharedCacheFd)
+      {
+         close(db->sharedCacheFd);
+         db->sharedCacheFd = -1;
+      }
+      db->alreadyOpen = Kdb_false;
+      db->htSize = 0;
+      //db->cacheReferenced = 0;
+      db->keySize = 0;
+      db->valSize = 0;
+      db->htSizeBytes = 0;
+      db->htMappedSize = 0;
+      db->dbMappedSize = 0;
+      db->shmCreator = 0;
+
+      Kdb_unlock(&db->shared->rwlock);
+
+      //Clean up for last instance referencing the database
+      if (db->shared->refCount == 0)
+      {
+         //close shared hashtable memory
+         if (db->htFd)
+         {
+            kdbShmemClose(db->htFd, db->htName);
+            db->htFd = 0;
+         }
+         if(db->htName != NULL)
+         {
+            free(db->htName);
+            db->htName = NULL;
+         }
+         //free rwlocks
+         pthread_rwlock_destroy(&db->shared->rwlock);
+         if (db->shared != NULL)
+         {
+            munmap(db->shared, sizeof(Shared_Data_s));
+            db->shared = NULL;
+         }
+         if (db->sharedFd)
+         {
+            kdbShmemClose(db->sharedFd, db->sharedName);
+            db->sharedFd = 0;
+         }
+         if(db->sharedName != NULL)
+         {
+            free(db->sharedName);
+            db->sharedName = NULL;
+         }
+
+         //destroy and unlock named semaphore only if ref counter is zero
+         if (-1 == sem_post(db->kdbSem)) //release semaphore
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_post() in cleanup failed: "),
+                  DLT_STRING(strerror(errno)));
+         }
+         if (-1 == sem_close(db->kdbSem))
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_close() in cleanup failed: "),
+                  DLT_STRING(strerror(errno)));
+         }
+         if (-1 == sem_unlink(db->semName))
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_unlink() in cleanup failed: "),
+                  DLT_STRING(strerror(errno)));
+         }
+         db->kdbSem = NULL;
+      }
+      else  //Clean up if other instances have reference to the database
+      {
+         if (db->sharedFd)
+         {
+            close(db->sharedFd);
+            db->sharedFd = 0;
+         }
+         if (db->htFd)
+         {
+            close(db->htFd);
+            db->htFd = 0;
+         }
+         if (db->shared != NULL)
+         {
+            munmap(db->shared, sizeof(Shared_Data_s));
+            db->shared = NULL;
+         }
+         if(db->htName != NULL)
+         {
+            free(db->htName);
+            db->htName = NULL;
+         }
+         if (-1 == sem_post(db->kdbSem))
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_post() in cleanup with refcounter > 0 failed: "),
+                  DLT_STRING(strerror(errno)));
+         }
+         if (-1 == sem_close(db->kdbSem))
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_close() in cleanup with refcounter > 0 failed: "),
+                    DLT_STRING(strerror(errno)));
+         }
+         db->kdbSem = NULL;
+      }
    }
-#endif
-   //sync changes with file
-   if (0 != msync(ptr, KISSDB_HEADER_SIZE, MS_SYNC | MS_INVALIDATE))
-      return KISSDB_ERROR_IO;
+}
 
-   //unmap memory
-   if (0 != munmap(ptr, KISSDB_HEADER_SIZE))
-      return KISSDB_ERROR_IO;
+
+int writeDualDataBlock(KISSDB* db, int64_t offset, int htNumber, const void* key, unsigned long klen, const void* value, int valueSize)
+{
+   DataBlock_s* backupBlock;
+   DataBlock_s* block;
+   uint64_t crc = 0x00;
+
+   block = (DataBlock_s*) (db->mappedDb + offset);
+   block->delimStart = DATA_BLOCK_A_START_DELIMITER;
+   memcpy(block->key,key, klen);
+   block->valSize = valueSize;
+   memcpy(block->value,value, block->valSize);
+   block->htNum = htNumber;
+   crc = 0x00;
+   crc = (uint32_t) pcoCrc32(crc, (unsigned char*)block->key, db->keySize + sizeof(uint32_t) + db->valSize + sizeof(uint64_t)); //crc over key, datasize, data and htnum
+   block->crc = crc;
+   block->delimEnd = DATA_BLOCK_A_END_DELIMITER;
+
+   // write same key and value again
+   backupBlock = (DataBlock_s*) ((char*) block + sizeof(DataBlock_s));
+   backupBlock->delimStart = DATA_BLOCK_B_START_DELIMITER;
+   backupBlock->crc = crc;
+   memcpy(backupBlock->key,key, klen);
+   backupBlock->valSize = valueSize;
+   memcpy(backupBlock->value,value, backupBlock->valSize);
+   backupBlock->htNum = htNumber;
+   backupBlock->delimEnd = DATA_BLOCK_B_END_DELIMITER;
 
    return 0;
 }
+
+
+int greatestCommonFactor(int x, int y)
+{
+   while (y != 0)
+   {
+      if (x > y)
+      {
+         x = x - y;
+      }
+      else
+      {
+         y = y - x;
+      }
+   }
+   return x;
+}
diff --git a/src/key-value-store/database/kissdb.h b/src/key-value-store/database/kissdb.h
index 90446ff..582e786 100644
--- a/src/key-value-store/database/kissdb.h
+++ b/src/key-value-store/database/kissdb.h
@@ -25,46 +25,68 @@
 #include <stdio.h>
 #include <stdint.h>
 #include <pthread.h>
+#include <semaphore.h>
 #include "../hashtable/qlibc.h"
+#include "../inc/protected/persComDbAccess.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-//#define __showTimeMeasurements
+/* #define __showTimeMeasurements */
+
+#define DATA_BLOCK_A_START_DELIMITER 0x2AAAAAAA
+#define DATA_BLOCK_A_END_DELIMITER   0x55555555
+
+#define DATA_BLOCK_B_START_DELIMITER 0xE38E38E3
+#define DATA_BLOCK_B_END_DELIMITER   0xAAAAAAA8
+
+#define DATA_BLOCK_A_DELETED_START_DELIMITER 0xAAAAAAAA
+#define DATA_BLOCK_A_DELETED_END_DELIMITER   0xD5555555
+
+#define DATA_BLOCK_B_DELETED_START_DELIMITER 0x7E07E07E
+#define DATA_BLOCK_B_DELETED_END_DELIMITER   0x81F81F81
+
+#define HASHTABLE_START_DELIMITER 0x33333333
+#define HASHTABLE_END_DELIMITER   0xCCCCCCCC
+
+#define HASHTABLE_SLOT_COUNT 510
 
 #ifdef __showTimeMeasurements
 #define SECONDS2NANO 1000000000L
 #define NANO2MIL        1000000L
 #define MIL2SEC            1000L
-// define for the used clock: "CLOCK_MONOTONIC" or "CLOCK_REALTIME"
+/*  define for the used clock: "CLOCK_MONOTONIC" or "CLOCK_REALTIME" */
 #define CLOCK_ID  CLOCK_MONOTONIC
 
 #endif
 
 
 /**
- * Version: 2
+ * Version: 2.3
  *
  * This is the file format identifier, and changes any time the file
- * format changes. The code version will be this dot something, and can
- * be seen in tags in the git repository.
+ * format changes.
  */
-#define KISSDB_VERSION 2
+#define KISSDB_MAJOR_VERSION 2
+#define KISSDB_MINOR_VERSION 3
 
-//boolean type
 typedef int16_t Kdb_bool;
 static const int16_t Kdb_true  = -1;
 static const int16_t Kdb_false =  0;
 
 typedef struct
 {
-      uint64_t shmem_size;
-      uint16_t num_hash_tables;
-      Kdb_bool cache_initialised;
-      Kdb_bool crc_invalid;
+      uint64_t htShmSize; /* shared info about current size of hashtable shared memory */
+      /*uint64_t cacheSize;*/
+      /*uint16_t cacheCount;*/
+      uint16_t htNum;
+      uint16_t refCount;
+      uint16_t openMode;
+      uint16_t writeMode;
+      Kdb_bool cacheCreated; /* flag to indicate if the shared cache was created */
       pthread_rwlock_t rwlock;
-      pthread_rwlock_t cache_rwlock;
+      uint64_t mappedDbSize; /* shared information about current mapped size of database file */
 } Shared_Data_s;
 
 
@@ -74,30 +96,49 @@ typedef struct
 typedef struct
 {
       char KdbV[8];
-      uint64_t checksum; // checksum over database file
+      uint64_t checksum; /* checksum over database file */
       uint64_t closeFailed;
       uint64_t closeOk;
-      uint64_t hash_table_size;
-      uint64_t key_size;
-      uint64_t value_size;
+      uint64_t htSize;
+      uint64_t keySize;
+      uint64_t valSize;
       char delimiter[8];
+      char padding[4032]; /* TODO remove padding*/
 } Header_s;
 
+typedef struct
+{
+   int64_t  delimStart;
+   uint64_t crc;
+   char     key[PERS_DB_MAX_LENGTH_KEY_NAME];
+   uint32_t valSize;
+   char     value[PERS_DB_MAX_SIZE_KEY_DATA]; /* 8028, 12124, 16220 -- > PERS_DB_MAX_SIZE_KEY_DATA = (pagesize * n) - (PERS_DB_MAX_LENGTH_KEY_NAME + 36) */
+   uint64_t htNum; /*index which hashtable stores the offset for this data block */
+   int64_t  delimEnd;
+} DataBlock_s;
 
 
 /**
- * Hashtable slot entry -> same size for all struct members because of alignment problems on target system!!
+ * Hashtable slot entry -for usage with mmap -> 24 byte --> use 510 + 1 slots
  */
 typedef struct
 {
       int64_t offsetA;
-      uint64_t checksumA;
       int64_t offsetB;
-      uint64_t checksumB;
       uint64_t current; //flag which offset points to the current data -> (if 0x00 offsetA points to current data, if 0x01 offsetB)
 } Hashtable_slot_s;
 
 
+//hashtable structure (size is multiple of 4096 byte for usage in shared memory)
+typedef struct
+{
+   int64_t delimStart;
+   uint64_t crc;
+   Hashtable_slot_s slots[HASHTABLE_SLOT_COUNT + 1]; //510 + 1 item (link to next hashtable) -> 12264 byte
+   int64_t delimEnd;
+} Hashtable_s; //12288 byte -> 3 pages of 4096 byte
+
+
 
 /**
  * KISSDB database
@@ -105,23 +146,28 @@ typedef struct
  * These fields should never be changed.
  */
 typedef struct {
-        uint16_t hash_table_size;
-        uint64_t key_size;
-        uint64_t value_size;
-        uint64_t hash_table_size_bytes;
-        uint64_t old_mapped_size;
-        Kdb_bool shmem_creator;
-        Kdb_bool already_open;
-        Hashtable_slot_s *hash_tables; //shared: stores the hashtables
-        void* shmem_cached; //shared: memory for key-value pair caching
-        int shmem_info_fd;
-        int shmem_ht_fd;
-        int shmem_cached_fd;
-        char* shmem_info_name;
-        char* shmem_cached_name;
-        char* shmem_ht_name;
-        Shared_Data_s* shmem_info;
-        qhasharr_t *tbl;   //reference to cached datastructure
+        uint16_t htSize;
+        //uint16_t cacheReferenced;
+        uint64_t keySize;
+        uint64_t valSize;
+        uint64_t htSizeBytes;
+        uint64_t htMappedSize; //local info about currently mapped hashtable size for this process
+        uint64_t dbMappedSize; //local info about currently mapped database  size for this process
+        Kdb_bool shmCreator;   //local information if this instance is the creator of the shared memory
+        Kdb_bool alreadyOpen;
+        Hashtable_s* hashTables; //local pointer to hashtables in shared memory
+        char* mappedDb; // local mapping of database file for every process
+        void* sharedCache; //shared: memory for key-value pair caching
+        int sharedFd;
+        int htFd;
+        int sharedCacheFd;
+        char* semName;
+        char* sharedName;
+        char* cacheName;
+        char* htName;
+        Shared_Data_s* shared;
+        qhasharr_t *tbl[1];   //reference to cache
+        sem_t* kdbSem;
         int fd; //local fd
 } KISSDB;
 
@@ -152,11 +198,6 @@ typedef struct {
 #define KISSDB_ERROR_ACCESS_VIOLATION -5
 
 /**
- * Unable to unmap shared memory
- */
-#define KISSDB_ERROR_UNMAP_SHM -6
-
-/**
  * Unable to open shared memory
  */
 #define KISSDB_ERROR_OPEN_SHM -7
@@ -182,6 +223,16 @@ typedef struct {
 #define KISSDB_ERROR_CLOSE_SHM -11
 
 /**
+ * try to open database with wrong version
+ */
+#define KISSDB_ERROR_WRONG_DATABASE_VERSION -12
+
+/**
+ * buffer where data should be returned is too small
+ */
+#define KISSDB_ERROR_WRONG_BUFSIZE -13
+
+/**
  * Open mode: read only
  */
 #define KISSDB_OPEN_MODE_RDONLY 1
@@ -202,6 +253,18 @@ typedef struct {
 #define KISSDB_OPEN_MODE_RWREPLACE 4
 
 /**
+ * Write mode: cache is not used, data is directly written (writeThrough mode)
+ */
+#define KISSDB_WRITE_MODE_WT 5
+
+/**
+ * Write mode: cache is used for database access
+ */
+#define KISSDB_WRITE_MODE_WC 6
+
+
+
+/**
  * Open database
  *
  * The three _size parameters must be specified if the database could
@@ -212,7 +275,8 @@ typedef struct {
  *
  * @param db Database struct
  * @param path Path to file
- * @param mode One of the KISSDB_OPEN_MODE constants
+ * @param openMode One of the KISSDB_OPEN_MODE constants
+ * @param writeMode One of the KISSDB_WRITE constants
  * @param hash_table_size Size of hash table in entries (must be >0)
  * @param key_size Size of keys in bytes
  * @param value_size Size of values in bytes
@@ -221,7 +285,8 @@ typedef struct {
 extern int KISSDB_open(
 	KISSDB *db,
 	const char *path,
-	int mode,
+	int openMode,
+	int writeMode,
         uint16_t hash_table_size,
 	uint64_t key_size,
         uint64_t value_size);
@@ -242,7 +307,7 @@ extern int KISSDB_close(KISSDB *db);
  * @param vbuf Value buffer (value_size bytes capacity)
  * @return negative on error (see kissdb.h for error codes), 0 on success, 1 if key not found
  */
-extern int KISSDB_get(KISSDB *db,const void *key,void *vbuf);
+extern int KISSDB_get(KISSDB *db,const void *key,void *vbuf, uint32_t bufsize, uint32_t* vsize);
 
 
 
@@ -253,7 +318,7 @@ extern int KISSDB_get(KISSDB *db,const void *key,void *vbuf);
  * @param key Key (key_size bytes)
  * @return negative on error (see kissdb.h for error codes), 0 on success, 1 if key not found
  */
-extern int KISSDB_delete(KISSDB *db,const void *key);
+extern int KISSDB_delete(KISSDB *db,const void *key, int32_t* bytesDeleted);
 
 /**
  * Put an entry (overwriting it if it already exists)
@@ -266,7 +331,7 @@ extern int KISSDB_delete(KISSDB *db,const void *key);
  * @param value Value (value_size bytes)
  * @return negative on error (see kissdb.h for error codes) error, 0 on success
  */
-extern int KISSDB_put(KISSDB *db,const void *key,const void *value);
+extern int KISSDB_put(KISSDB *db,const void *key,const void *value, int valueSize, int32_t* bytesWritten);
 
 /**
  * Cursor used for iterating over all entries in database
@@ -297,8 +362,6 @@ extern void KISSDB_Iterator_init(KISSDB *db,KISSDB_Iterator *dbi);
  * @return 0 if there are no more entries, negative on error, positive if kbuf/vbuf have been filled
  */
 extern int KISSDB_Iterator_next(KISSDB_Iterator *dbi,void *kbuf,void *vbuf);
-
-
 extern Kdb_bool freeKdbShmemPtr(void * shmem_ptr, size_t length);
 extern void * getKdbShmemPtr(int shmem, size_t length);
 extern Kdb_bool kdbShmemClose(int shmem, const char * shmName);
@@ -307,9 +370,20 @@ extern char * kdbGetShmName(const char * format, const char * path);
 extern void Kdb_wrlock(pthread_rwlock_t * wrlock);
 extern void Kdb_rdlock(pthread_rwlock_t * rdlock);
 extern void Kdb_unlock(pthread_rwlock_t * lock);
-extern int readHeader(KISSDB* db, uint16_t* hash_table_size, uint64_t* key_size, uint64_t* value_size);
-extern int writeHeader(KISSDB* db, uint16_t* hash_table_size, uint64_t* key_size, uint64_t* value_size);
+extern int readHeader(KISSDB* db, uint16_t* htSize, uint64_t* keySize, uint64_t* valSize);
+extern int writeHeader(KISSDB* db, uint16_t* htSize, uint64_t* keySize, uint64_t* valSize);
+extern int writeDualDataBlock(KISSDB* db, int64_t offset, int htNumber, const void* key, unsigned long klen, const void* value, int valueSize);
 extern int checkErrorFlags(KISSDB* db);
+extern int verifyHashtableCS(KISSDB* db);
+extern int rebuildHashtables(KISSDB* db);
+extern int greatestCommonFactor(int x, int y);
+extern void invalidateBlocks(DataBlock_s* dataA, DataBlock_s* dataB, KISSDB* db);
+extern void invertBlockOffsets(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB);
+extern void rebuildWithBlockB(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB);
+extern void rebuildWithBlockA(DataBlock_s* data, KISSDB* db, int64_t offsetA, int64_t offsetB);
+extern int recoverDataBlocks(KISSDB* db);
+extern int checkIsLink(const char* path, char* linkBuffer);
+extern void cleanKdbStruct(KISSDB* db);
 
 #if 0
 extern void printSharedHashtable(KISSDB *db);
@@ -319,5 +393,5 @@ extern void printSharedHashtable(KISSDB *db);
 }
 #endif
 
-#endif
+#endif //___KISSDB_H
 
diff --git a/src/key-value-store/hashtable/qhash.h b/src/key-value-store/hashtable/qhash.h
index b873799..027bc60 100644
--- a/src/key-value-store/hashtable/qhash.h
+++ b/src/key-value-store/hashtable/qhash.h
@@ -48,14 +48,7 @@ extern "C" {
 #endif

 

 extern bool qhashmd5(const void *data, size_t nbytes, void *retbuf);

-//extern bool qhashmd5_file(const char *filepath, off_t offset, ssize_t nbytes,

-//                          void *retbuf);

-

-//extern uint32_t qhashfnv1_32(const void *data, size_t nbytes);

-//extern uint64_t qhashfnv1_64(const void *data, size_t nbytes);

-

 extern uint32_t qhashmurmur3_32(const void *data, size_t nbytes);

-//extern bool qhashmurmur3_128(const void *data, size_t nbytes, void *retbuf);

 

 #ifdef __cplusplus

 }

diff --git a/src/key-value-store/hashtable/qhasharr.c b/src/key-value-store/hashtable/qhasharr.c
index 97169bf..3602e84 100644
--- a/src/key-value-store/hashtable/qhasharr.c
+++ b/src/key-value-store/hashtable/qhasharr.c
@@ -150,6 +150,7 @@
 #include "qhash.h"
 #include "qhasharr.h"
 
+
 #ifndef _DOXYGEN_SKIP
 
 static bool put(qhasharr_t *tbl, const char *key, const void *value,
@@ -165,6 +166,8 @@ static int size(qhasharr_t *tbl, int *maxslots, int *usedslots);
 
 static void free_(qhasharr_t *tbl);
 
+
+
 // internal usages
 static int _find_empty(qhasharr_t *tbl, int startidx);
 static int _get_idx(qhasharr_t *tbl, const char *key, unsigned int hash);
@@ -217,56 +220,67 @@ size_t qhasharr_calculate_memsize(int max) {
  *  qhasharr_t *tbl2 = qhasharr(memory, 0);
  * @endcode
  */
-qhasharr_t *qhasharr(void *memory, size_t memsize) {
-    // Structure memory.
-    qhasharr_data_t *data = (qhasharr_data_t *) memory;
-
-    // Initialize data if memsize is set or use existing data.
-    if (memsize > 0) {
-        // calculate max
-        int maxslots = (memsize - sizeof(qhasharr_data_t))
-                / sizeof(qhasharr_slot_t);
-        if (maxslots < 1 || memsize <= sizeof(qhasharr_t)) {
-            //errno = EINVAL;
-            return NULL;
-        }
-
-        // Set memory.
-        //memset((void *) data, 0, memsize); //TODO check if initialisation is needed
-        data->maxslots = maxslots;
-        data->usedslots = 0;
-        data->num = 0;
-    }
-
-    // Set data address. Shared memory returns virtul address.
-    data->slots = (qhasharr_slot_t *) (memory + sizeof(qhasharr_data_t));
-
-    // Create the table object.
-    qhasharr_t *tbl = (qhasharr_t *) malloc(sizeof(qhasharr_t));
-    if (tbl == NULL) {
-        //errno = ENOMEM;
-        return NULL;
-    }
-    memset((void *) tbl, 0, sizeof(qhasharr_t));
-
-    // assign methods
-    tbl->put = put;
-
-    tbl->get = get;
-
-    tbl->getnext = getnext;
-
-    tbl->remove = remove_;
-
-    tbl->size = size;
+qhasharr_t *qhasharr(void *memory, size_t memsize)
+{
+// Structure memory.
+   qhasharr_data_t *data = (qhasharr_data_t *) memory;
+
+   //printf("qhasharr memory pointer: %p \n", memory);
+// Initialize data if memsize is set or use existing data.
+   if (memsize > 0)
+   {
+// calculate max
+      int maxslots = (memsize - sizeof(qhasharr_data_t)) / sizeof(qhasharr_slot_t);
+      if (maxslots < 1 || memsize <= sizeof(qhasharr_t))
+      {
+         errno = EINVAL;
+         return NULL;
+      }
+// Set memory.
+      memset((void *) data, 0, memsize);
+      data->maxslots = maxslots;
+      data->usedslots = 0;
+      data->num = 0;
+   }
+   //printf("Memory address: %p, sizeof(qhasharr_data_t): %d \n", memory, sizeof(qhasharr_data_t));
+// Set data address. Shared memory returns virtul address.
+   data->slots = (qhasharr_slot_t *) (memory + sizeof(qhasharr_data_t));
+
+// Create the table object.
+   qhasharr_t *tbl = (qhasharr_t *) malloc(sizeof(qhasharr_t));
+   if (tbl == NULL)
+   {
+      errno = ENOMEM;
+      return NULL;
+   }
+   memset((void *) tbl, 0, sizeof(qhasharr_t));
+// assign methods
+   tbl->put = put;
+   tbl->get = get;
+   tbl->getnext = getnext;
+   tbl->remove = remove_;
+   tbl->size = size;
+   tbl->free = free_;
+   tbl->data = data;
+   return tbl;
+}
 
-    tbl->free = free_;
 
-    tbl->data = data;
 
-    return tbl;
+/**
+ * setMemoryAddress(): resets the mapped shared memory pointer.
+ *
+ * @param memory    pointer to shared memory.
+ * @param tbl       qhasharr_t container pointer
+ */
+void setMemoryAddress(void* memory, qhasharr_t *tbl )
+{
+   qhasharr_data_t *data = (qhasharr_data_t *) memory;
+   data->slots = (qhasharr_slot_t *) (memory + sizeof(qhasharr_data_t));
+   tbl->data = data;
 }
 
+
 /**
  * qhasharr->put(): Put an object into this table.
  *
@@ -284,19 +298,21 @@ qhasharr_t *qhasharr(void *memory, size_t memsize) {
 static bool put(qhasharr_t *tbl, const char *key, const void *value,
                 size_t size) {
     if (tbl == NULL || key == NULL || value == NULL) {
-        //errno = EINVAL;
+        errno = EINVAL;
         return false;
     }
 
     qhasharr_data_t *data = tbl->data;
-
+    //printf("put data-> ptr= %p ---- MAXSLOTS = %d \n", data, data->maxslots);
     // check full
     if (data->usedslots >= data->maxslots || ((data->usedslots + (size / 32)) >= data->maxslots))  {
         //DEBUG("hasharr: put %s - FULL", key);
-        //errno = ENOBUFS;
+        errno = ENOBUFS;
+        //printf("CACHE TOO SMALL \n");
         return false;
     }
 
+
     // get hash integer
     unsigned int hash = qhashmurmur3_32(key, strlen(key)) % data->maxslots;
 
@@ -314,13 +330,12 @@ static bool put(qhasharr_t *tbl, const char *key, const void *value,
         if (idx >= 0) {  // same key
             // remove and recall
             remove_(tbl, key);
-            //printf("overwriting existent key 2%s\n", key);
             return put(tbl, key, value, size);
         } else {  // no same key, just hash collision
             // find empty slot
             int idx = _find_empty(tbl, hash);
             if (idx < 0) {
-                //errno = ENOBUFS;
+                errno = ENOBUFS;
                 return false;
             }
 
@@ -339,11 +354,10 @@ static bool put(qhasharr_t *tbl, const char *key, const void *value,
     } else {
         // in case of -1 or -2, move it. -1 used for collision resolution,
         // -2 used for oversized value data.
-
         // find empty slot
         int idx = _find_empty(tbl, hash + 1);
         if (idx < 0) {
-            //errno = ENOBUFS;
+            errno = ENOBUFS;
             return false;
         }
 
@@ -396,18 +410,14 @@ static void *get(qhasharr_t *tbl, const char *key, size_t *size) {
         //errno = EINVAL;
         return NULL;
     }
-
     qhasharr_data_t *data = tbl->data;
-
     // get hash integer
     unsigned int hash = qhashmurmur3_32(key, strlen(key)) % data->maxslots;
-
     int idx = _get_idx(tbl, key, hash);
     if (idx < 0) {
         //errno = ENOENT;
         return NULL;
     }
-
     return _get_data(tbl, idx, size);
 }
 
@@ -446,12 +456,10 @@ static bool getnext(qhasharr_t *tbl, qnobj_t *obj, int *idx) {
     }
 
     qhasharr_data_t *data = tbl->data;
-
     for (; *idx < data->maxslots; (*idx)++) {
         if (data->slots[*idx].count == 0 || data->slots[*idx].count == -2) {
             continue;
         }
-
         size_t keylen = data->slots[*idx].data.pair.keylen;
         if (keylen > _Q_HASHARR_KEYSIZE)
             keylen = _Q_HASHARR_KEYSIZE;
@@ -580,7 +588,9 @@ static int size(qhasharr_t *tbl, int *maxslots, int *usedslots) {
     if (maxslots != NULL)
         *maxslots = data->maxslots;
     if (usedslots != NULL)
+    {
         *usedslots = data->usedslots;
+    }
 
     return data->num;
 }
@@ -669,7 +679,6 @@ static int _get_idx(qhasharr_t *tbl, const char *key, unsigned int hash) {
             continue;
         }
     }
-
     return -1;
 }
 
@@ -678,7 +687,6 @@ static void *_get_data(qhasharr_t *tbl, int idx, size_t *size) {
         //errno = ENOENT;
         return NULL;
     }
-
     qhasharr_data_t *data = tbl->data;
 
     int newidx;
@@ -753,7 +761,7 @@ static bool _put_data(qhasharr_t *tbl, int idx, unsigned int hash,
             if (tmpidx < 0) {
                 //DEBUG("hasharr: Can't expand slot for key %s.", key);
                 _remove_data(tbl, idx);
-                //errno = ENOBUFS;
+                errno = ENOBUFS;
                 return false;
             }
 
@@ -818,7 +826,6 @@ static bool _copy_slot(qhasharr_t *tbl, int idx1, int idx2) {
 
     // increase used slot counter
     data->usedslots++;
-
     return true;
 }
 
@@ -837,7 +844,6 @@ static bool _remove_slot(qhasharr_t *tbl, int idx)
 
     // decrease used slot counter
     data->usedslots--;
-
     return true;
 }
 
diff --git a/src/key-value-store/hashtable/qhasharr.h b/src/key-value-store/hashtable/qhasharr.h
index 37d52f3..2c00977 100644
--- a/src/key-value-store/hashtable/qhasharr.h
+++ b/src/key-value-store/hashtable/qhasharr.h
@@ -54,7 +54,7 @@ extern "C" {
 #define _Q_HASHARR_VALUESIZE (32)  /*!< knob for maximum data size in a slot. */

 

 #define PERS_CACHE_MAX_SLOTS 100000 /**< Max. number of slots in the cache */

-#define PERS_CACHE_MEMSIZE (sizeof(qhasharr_data_t)+ (sizeof(qhasharr_slot_t) * (PERS_CACHE_MAX_SLOTS))) //approximately 2 MB

+#define PERS_CACHE_MEMSIZE (sizeof(qhasharr_data_t)+ (sizeof(qhasharr_slot_t) * (PERS_CACHE_MAX_SLOTS)))

 

 /* types */

 typedef struct qhasharr_slot_s qhasharr_slot_t;

@@ -64,7 +64,7 @@ typedef struct qhasharr_s qhasharr_t;
 /* public functions */

 extern qhasharr_t *qhasharr(void *memory, size_t memsize);

 extern size_t qhasharr_calculate_memsize(int max);

-

+extern void setMemoryAddress(void* memory, qhasharr_t *tbl);

 /**

  * qhasharr internal data slot structure

  */

diff --git a/src/key-value-store/pers_low_level_db_access.c b/src/key-value-store/pers_low_level_db_access.c
index 1ca2b27..71f49ce 100644
--- a/src/key-value-store/pers_low_level_db_access.c
+++ b/src/key-value-store/pers_low_level_db_access.c
@@ -1,4 +1,4 @@
- /******************************************************************************
+/******************************************************************************
  * Project         Persistency
  * (c) copyright   2014
  * Company         XS Embedded GmbH
@@ -7,21 +7,21 @@
  * This Source Code Form is subject to the terms of the
  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed
  * with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
-******************************************************************************/
- /**
+ ******************************************************************************/
+/**
  * @file           pers_low_level_db_access.c
  * @author         Simon Disch
  * @brief          Implementation of persComDbAccess.h
  * @see
  */
 
-
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <malloc.h>
 #include <sys/types.h>
+#include <sys/mman.h>
 #include <unistd.h>
 #include "./database/kissdb.h"
 #include "./hashtable/qlibc.h"
@@ -32,20 +32,40 @@
 #include "persComDbAccess.h"
 #include "persComRct.h"
 #include "pers_low_level_db_access_if.h"
-#include "dlt.h"
+#include <dlt.h>
 #include <errno.h>
 #include <sys/time.h>
+#include <sys/shm.h>
+
+
+/* #define PFS_TEST */
+
 /* L&T context */
 #define LT_HDR                          "[persComLLDB]"
+DltContext persComLldbDLTCtx;
+DLT_DECLARE_CONTEXT   (persComLldbDLTCtx)
+
+
+
+///// library constructor
+//void pco_library_init(void) __attribute__((constructor));
+//void pco_library_init() {
+//    printf ("\n      pco_library_init() constructor \n");
+//}
+//
+///// library destructor
+//void pco_library_destroy(void) __attribute__((destructor));
+//void pco_library_destroy() {
+//    printf ("\n      pco_library_destroy() destructor \n");
+//}
 
-DLT_DECLARE_CONTEXT(persComLldbDLTCtx);
 
 /* ---------------------- local definition  ---------------------------- */
 /* max number of open handlers per process */
 #define PERS_LLDB_NO_OF_STATIC_HANDLES 16
 #define PERS_LLDB_MAX_STATIC_HANDLES (PERS_LLDB_NO_OF_STATIC_HANDLES-1)
 
-#define PERS_STATUS_KEY_NOT_IN_CACHE             -10        //!< key not in cache
+#define PERS_STATUS_KEY_NOT_IN_CACHE             -10        /* /!< key not in cache */
 
 typedef struct
 {
@@ -56,7 +76,7 @@ typedef struct
 typedef enum pers_lldb_cache_flag_e
 {
    CachedDataDelete = 0, /* Resource-Configuration-Table */
-   CachedDataWrite, /* Local/Shared DB */
+   CachedDataWrite /* Local/Shared DB */
 } pers_lldb_cache_flag_e;
 
 typedef struct
@@ -85,7 +105,7 @@ typedef struct
 typedef struct lldb_handles_list_el_s_
 {
    lldb_handler_s sHandle;
-   struct lldb_handles_list_el_s_ * pNext;
+   struct lldb_handles_list_el_s_* pNext;
 } lldb_handles_list_el_s;
 
 typedef struct
@@ -98,7 +118,8 @@ typedef struct
 static const char ListItemsSeparator = '\0';
 
 /* shared by all the threads within a process */
-static lldb_handlers_s g_sHandlers = { { { 0 } } };
+static lldb_handlers_s g_sHandlers; // initialize to 0 and NULL
+//static lldb_handlers_s g_sHandlers = { { { 0 } } };
 static pthread_mutex_t g_mutexLldb = PTHREAD_MUTEX_INITIALIZER;
 
 /* ---------------------- local macros  --------------------------------- */
@@ -112,24 +133,26 @@ static sint_t GetKeySizeFromKissLocalDB(sint_t dbHandler, pconststr_t key);
 static sint_t GetDataFromKissLocalDB(sint_t dbHandler, pconststr_t key, pstr_t buffer_out, sint_t bufSize);
 static sint_t GetDataFromKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s* pConfig);
 static sint_t SetDataInKissLocalDB(sint_t dbHandler, pconststr_t key, pconststr_t data, sint_t dataSize);
-static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s const * pConfig);
+static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s const* pConfig);
 static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler);
 static sint_t writeBackKissRCT(KISSDB* db, lldb_handler_s* pLldbHandler);
 static sint_t getListandSize(KISSDB* db, pstr_t buffer, sint_t size, bool_t bOnlySizeNeeded, pers_lldb_purpose_e purpose);
-static sint_t putToCache(KISSDB* db, sint_t dataSize, char* tmp_key, void* insert_cached_data);
-static sint_t getFromCache(KISSDB* db, void* tmp_key, void* readBuffer, sint_t bufsize, bool_t sizeOnly);
-static sint_t getFromDatabaseFile(KISSDB* db, void* tmp_key, void* readBuffer, pers_lldb_purpose_e purpose, sint_t bufsize, bool_t sizeOnly);
+static sint_t putToCache(KISSDB* db, sint_t dataSize, char* metaKey, void* cachedData);
+static sint_t deleteFromCache(KISSDB* db, char* metaKey);
+static sint_t getFromCache(KISSDB* db, void* metaKey, void* readBuffer, sint_t bufsize, bool_t sizeOnly);
+static sint_t getFromDatabaseFile(KISSDB* db, void* metaKey, void* readBuffer, sint_t bufsize);
 
 /* access to resources shared by the threads within a process */
 static bool_t lldb_handles_Lock(void);
 static bool_t lldb_handles_Unlock(void);
 static lldb_handler_s* lldb_handles_FindInUseHandle(sint_t dbHandler);
 static lldb_handler_s* lldb_handles_FindAvailableHandle(void);
-static void lldb_handles_InitHandle(lldb_handler_s* psHandle_inout, pers_lldb_purpose_e ePurpose, str_t const * dbPathname);
+static void lldb_handles_InitHandle(lldb_handler_s* psHandle_inout, pers_lldb_purpose_e ePurpose, str_t const* dbPathname);
 static bool_t lldb_handles_DeinitHandle(sint_t dbHandler);
 
 static int createCache(KISSDB* db);
 static int openCache(KISSDB* db);
+//static int addCache(KISSDB* db);
 static int closeCache(KISSDB* db);
 
 /**
@@ -142,15 +165,22 @@ static int closeCache(KISSDB* db);
  *
  * \return >=0 for success, negative value otherway (see pers_error_codes.h)
  */
-sint_t pers_lldb_open(str_t const * dbPathname, pers_lldb_purpose_e ePurpose, bool_t bForceCreationIfNotPresent)
+sint_t pers_lldb_open(str_t const* dbPathname, pers_lldb_purpose_e ePurpose, bool_t bForceCreationIfNotPresent)
 {
-   sint_t returnValue = PERS_COM_FAILURE;
    bool_t bCanContinue = true;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
-   int mode = KISSDB_OPEN_MODE_RDWR;
+   char linkBuffer[256] = { 0 };
+   const char* path;
+   int error = 0;
+   int kdbState = 0;
+   int openMode  = KISSDB_OPEN_MODE_RDWR; //default is open existing in RDWR
+   int writeMode = KISSDB_WRITE_MODE_WC;  //default is write cached
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t returnValue = PERS_COM_FAILURE;
    static bool_t bFirstCall = true;
 
+   path = dbPathname;
+
    if (bFirstCall)
    {
       pid_t pid = getpid();
@@ -161,12 +191,14 @@ sint_t pers_lldb_open(str_t const * dbPathname, pers_lldb_purpose_e ePurpose, bo
       /* init DLT */
       (void) snprintf(dltContextID, sizeof(dltContextID), "Pers_%04d", pid);
       DLT_REGISTER_CONTEXT(persComLldbDLTCtx, dltContextID, "PersCommonLLDB");
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("register context PersCommonLLDB ContextID="); DLT_STRING(dltContextID));
+      //DLT_SET_APPLICATION_LL_TS_LIMIT(DLT_LOG_DEBUG, DLT_TRACE_STATUS_OFF);
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+              DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("register context PersCommonLLDB ContextID="); DLT_STRING(dltContextID));
    }
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING("Begin opening:"); DLT_STRING("<<"); DLT_STRING(dbPathname); DLT_STRING(">>, "); ((PersLldbPurpose_RCT == ePurpose) ? DLT_STRING("RCT, ") : DLT_STRING("DB, ")); ((true == bForceCreationIfNotPresent) ? DLT_STRING("forced, ") : DLT_STRING("unforced, ")); DLT_STRING(" ... "));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING("Begin opening:"); DLT_STRING("<"); DLT_STRING(dbPathname); DLT_STRING(">, ");
+           ((PersLldbPurpose_RCT == ePurpose) ? DLT_STRING("RCT, ") : DLT_STRING("DB, ")); ((true == bForceCreationIfNotPresent) ? DLT_STRING("forced, ") : DLT_STRING("unforced, ")));
 
    if (lldb_handles_Lock())
    {
@@ -179,58 +211,158 @@ sint_t pers_lldb_open(str_t const * dbPathname, pers_lldb_purpose_e ePurpose, bo
       }
    }
    else
+   {
       bCanContinue = false;
+   }
    if (bCanContinue)
    {
-      int kissdb_state = 0;
-      size_t datasize =
-            (PersLldbPurpose_RCT == ePurpose) ? sizeof(PersistenceConfigurationKey_s) : sizeof(Data_LocalDB_s);
-      size_t keysize =
-            (PersLldbPurpose_RCT == ePurpose) ? PERS_RCT_MAX_LENGTH_RESOURCE_ID : PERS_DB_MAX_LENGTH_KEY_NAME;
+      size_t datasize = (PersLldbPurpose_RCT == ePurpose) ? sizeof(PersistenceConfigurationKey_s) :
+                        PERS_DB_MAX_SIZE_KEY_DATA;
+      size_t keysize = (PersLldbPurpose_RCT == ePurpose) ? PERS_RCT_MAX_LENGTH_RESOURCE_ID :
+                       PERS_DB_MAX_LENGTH_KEY_NAME;
 
-      if (bForceCreationIfNotPresent  & (1 << 0) ) //check bit 0
-         mode = KISSDB_OPEN_MODE_RWCREAT;
+      if (bForceCreationIfNotPresent & (1 << 0)) //check bit 0 0x0 (open)  0x1 (create)
+      {
+         openMode = KISSDB_OPEN_MODE_RWCREAT; //bit 0 is set
+      }
+      if(bForceCreationIfNotPresent & (1 << 1)) //check bit 1
+      {
+         //bit 1 is set -> writeThrough mode 0x2 (open) 0x3 (create)
+         writeMode = KISSDB_WRITE_MODE_WT;
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR), DLT_STRING(__FUNCTION__), DLT_STRING("Opening in write through mode:"), DLT_STRING("<"),
+                 DLT_STRING(dbPathname), DLT_STRING(">, "));
+      }
+      if( bForceCreationIfNotPresent & (1 << 2)) //check bit 2
+      {
+         openMode = KISSDB_OPEN_MODE_RDONLY; //bit 2 is set 0x4
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR), DLT_STRING(__FUNCTION__), DLT_STRING("Opening in read only mode:"), DLT_STRING("<"),
+                 DLT_STRING(dbPathname), DLT_STRING(">, "));
+      }
 
-#ifdef __writeThrough
-      if(bForceCreationIfNotPresent & (1 << 1))   //check bit 1
-         printf("cached \n");
+      if (1 == checkIsLink(dbPathname, linkBuffer))
+      {
+         path = linkBuffer;
+      }
       else
-         printf("uncached \n");
-#endif
+      {
+         path = dbPathname;
+      }
 
-      kissdb_state = KISSDB_open(&pLldbHandler->kissDb, dbPathname, mode, 256, keysize, datasize);
-      if (kissdb_state != 0)
+      //printKdb(&pLldbHandler->kissDb);
+
+      if (pLldbHandler->kissDb.alreadyOpen == Kdb_false) //check if this instance has already opened the db before
       {
-         DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-               DLT_STRING("KISSDB_open: "); DLT_STRING("<<"); DLT_STRING(dbPathname); DLT_STRING(">>, "); DLT_STRING(" retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"), DLT_STRING(strerror(errno)));
+         pLldbHandler->kissDb.semName = kdbGetShmName("-sem", path);
+         if (NULL == pLldbHandler->kissDb.semName)
+         {
+            return -1;
+         }
+         pLldbHandler->kissDb.kdbSem = sem_open(pLldbHandler->kissDb.semName, O_CREAT | O_EXCL, 0644, 1);
+         error = errno; //store errno -> (errno could be modified by following DLT_LOG)
+         if (pLldbHandler->kissDb.kdbSem == SEM_FAILED) //open failed
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+                    DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(": first sem_open() with mode O_CREAT | O_EXCL failed with: "); DLT_STRING(strerror(error)));
+            if (error == EEXIST)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+                       DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(": semaphore already exists: "); DLT_STRING(strerror(error)));
+               //try to open existing semaphore
+               pLldbHandler->kissDb.kdbSem = sem_open(pLldbHandler->kissDb.semName, O_CREAT, 0644, 0);
+               error = errno;
+               if (pLldbHandler->kissDb.kdbSem == SEM_FAILED) //open failed
+               {
+                  DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                          DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(": sem_open() for existing semaphore failed with error: "); DLT_STRING(strerror(error)));
+                  return -1;
+               }
+            }
+            else
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                       DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":sem_open() failed:"); DLT_STRING(strerror(error)));
+               return -1;
+            }
+         }
+      }
+      if (-1 == sem_wait(pLldbHandler->kissDb.kdbSem))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_wait() in open failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
+      kdbState = KISSDB_open(&pLldbHandler->kissDb, path, openMode, writeMode, HASHTABLE_SLOT_COUNT, keysize, datasize);
+      if (kdbState != 0)
+      {
+         if (kdbState == KISSDB_ERROR_WRONG_DATABASE_VERSION)
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                    DLT_STRING("KISSDB_open: "); DLT_STRING("<"); DLT_STRING(path); DLT_STRING(">, "); DLT_STRING("database to be opened has wrong version! retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
+         }
+         else
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
+                    DLT_STRING("KISSDB_open: "); DLT_STRING("<"); DLT_STRING(path); DLT_STRING(">, "); DLT_STRING(" retval=<"); DLT_INT(kdbState); DLT_STRING(">"),
+                    DLT_STRING(strerror(errno)));
+         }
          bCanContinue = false;
       }
-      if (bCanContinue)
+   }
+   if (kdbState == 0)
+   {
+      pLldbHandler->kissDb.shared->refCount++; //increment reference to opened databases
+      if (-1 == sem_post(pLldbHandler->kissDb.kdbSem)) //release semaphore
       {
-         lldb_handles_InitHandle(pLldbHandler, ePurpose, dbPathname);
-         returnValue = pLldbHandler->dbHandler;
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": End of open -> sem_post() failed: "),DLT_STRING(strerror(errno)));
       }
-      else
+   }
+   else
+   {
+      cleanKdbStruct(&pLldbHandler->kissDb);
+
+      //in case of cleanup failure for semaphores, release semaphore
+      if (pLldbHandler->kissDb.kdbSem != NULL)
       {
-         /* clean up */
-         returnValue = PERS_COM_FAILURE;
-         (void) lldb_handles_DeinitHandle(pLldbHandler->dbHandler);
+         if (-1 == sem_post(pLldbHandler->kissDb.kdbSem)) //release semaphore
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": End of open -> sem_post() in cleanup failed: "),
+                  DLT_STRING(strerror(errno)));
+         }
+      }
+
+      if(pLldbHandler->kissDb.semName != NULL)
+      {
+         free(pLldbHandler->kissDb.semName);
+         pLldbHandler->kissDb.semName = NULL;
       }
    }
 
+   if (bCanContinue)
+   {
+      lldb_handles_InitHandle(pLldbHandler, ePurpose, path);
+      returnValue = pLldbHandler->dbHandler;
+   }
+   else
+   {
+      /* clean up */
+      returnValue = PERS_COM_FAILURE;
+      (void) lldb_handles_DeinitHandle(pLldbHandler->dbHandler);
+   }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-        DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING("End of open for:"); DLT_STRING("<<"); DLT_STRING(dbPathname); DLT_STRING(">>, "); ((PersLldbPurpose_RCT == ePurpose) ? DLT_STRING("RCT, ") : DLT_STRING("DB, ")); ((true == bForceCreationIfNotPresent) ? DLT_STRING("forced, ") : DLT_STRING("unforced, ")); DLT_STRING("retval=<"); DLT_INT(returnValue); DLT_STRING(">"));
-
-   return returnValue;
-}
+   }
 
 
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR), DLT_STRING(__FUNCTION__), DLT_STRING("End of open for:"), DLT_STRING("<"),
+           DLT_STRING(dbPathname), DLT_STRING(">, "), ((PersLldbPurpose_RCT == ePurpose) ? DLT_STRING("RCT, ") : DLT_STRING("DB, ")),
+           ((true == bForceCreationIfNotPresent) ? DLT_STRING("forced, ") : DLT_STRING("unforced, ")); DLT_STRING("retval=<"), DLT_INT(returnValue),
+           DLT_STRING(">"));
 
+   return returnValue;
+}
 
 /**
- * \close a key-value database
+ * \brief close a key-value database
  * \note : DB type is identified from dbPathname (based on extension)
  *
  * \param handlerDB     [in] handler obtained with pers_lldb_open
@@ -239,19 +371,24 @@ sint_t pers_lldb_open(str_t const * dbPathname, pers_lldb_purpose_e ePurpose, bo
  */
 sint_t pers_lldb_close(sint_t handlerDB)
 {
-   int kissdb_state = 0;
-   sint_t returnValue = PERS_COM_SUCCESS;
-   lldb_handler_s* pLldbHandler = NIL;
+#ifdef PFS_TEST
+   printf("START: pers_lldb_close for PID: %d \n", getpid());
+#endif
+
    bool_t bLocked = false;
+   int kdbState = 0;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t returnValue = PERS_COM_SUCCESS;
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(handlerDB); DLT_STRING("..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(handlerDB));
 
 #ifdef __showTimeMeasurements
    long long duration = 0;
    long long KdbDuration = 0;
    long long writeDuration = 0;
-   struct timespec writeStart, writeEnd, kdbStart, kdbEnd, writebackStart, writebackEnd;
+   struct timespec writeStart, writeEnd, kdbStart, kdbEnd, writebackStart,
+             writebackEnd;
    duration = 0;
    KdbDuration = 0;
    writeDuration = 0;
@@ -266,118 +403,168 @@ sint_t pers_lldb_close(sint_t handlerDB)
          pLldbHandler = lldb_handles_FindInUseHandle(handlerDB);
 
          if (NIL == pLldbHandler)
+         {
             returnValue = PERS_COM_FAILURE;
+         }
       }
    }
    else
+   {
       returnValue = PERS_COM_ERR_INVALID_PARAM;
+   }
 
    if (PERS_COM_SUCCESS == returnValue)
    {
-      //persist cached data to flash memory
       KISSDB* db = &pLldbHandler->kissDb;
+      if (-1 == sem_wait(db->kdbSem))
+      {
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(": sem_wait() in close failed: "),
+                 DLT_STRING(strerror(errno)));
+      }
 
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-                DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Closing database  =<<"); DLT_STRING(pLldbHandler->dbPathname); DLT_STRING(">>, "));
-
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+              DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Closing database  =<"); DLT_STRING(pLldbHandler->dbPathname); DLT_STRING(">, "));
 
-      Kdb_wrlock(&db->shmem_info->cache_rwlock);
+      Kdb_wrlock(&db->shared->rwlock);         //lock acces to shared status information
 
-      if (db->shmem_info->cache_initialised == Kdb_true)
+      if (db->shared->refCount > 0)
       {
-         if (db->shmem_creator == Kdb_true)
+         db->shared->refCount--;
+      }
+      if (db->shared->cacheCreated == Kdb_true)
+      {
+         if (db->shared->refCount == 0)
          {
-            //open existing cache in existing shared memory
-            if (db->shmem_cached_fd <= 0)
+            if (openCache(db) != 0)
             {
-               if (openCache(db) != 0)
-               {
-                  Kdb_unlock(&db->shmem_info->cache_rwlock);
-                  return PERS_COM_FAILURE;
-               }
+               Kdb_unlock(&db->shared->rwlock);
+               return PERS_COM_FAILURE;
             }
 #ifdef __showTimeMeasurements
             clock_gettime(CLOCK_ID, &writebackStart);
 #endif
-            if (pLldbHandler->ePurpose == PersLldbPurpose_DB)  //write back to local database
-               writeBackKissDB(&pLldbHandler->kissDb, pLldbHandler);
-            else if (pLldbHandler->ePurpose == PersLldbPurpose_RCT) //write back to RCT database
+
+            if (db->shared->openMode != KISSDB_OPEN_MODE_RDONLY)
             {
-               writeBackKissRCT(&pLldbHandler->kissDb, pLldbHandler);
+#ifdef PFS_TEST
+               printf("  START: writeback of %d slots\n", pLldbHandler->kissDb.tbl->data->usedslots);
+#endif
+               if (pLldbHandler->ePurpose == PersLldbPurpose_DB)  //write back to local database
+               {
+                  writeBackKissDB(&pLldbHandler->kissDb, pLldbHandler);
+               }
+               else
+               {
+                  if (pLldbHandler->ePurpose == PersLldbPurpose_RCT) //write back to RCT database
+                  {
+                     writeBackKissRCT(&pLldbHandler->kissDb, pLldbHandler);
+                  }
+               }
+#ifdef PFS_TEST
+               printf("  END: writeback \n");
+#endif
             }
+
 #ifdef __showTimeMeasurements
             clock_gettime(CLOCK_ID, &writebackEnd);
 #endif
-            if (db->shmem_info->cache_initialised)
+            //release reference object
+            db->tbl[0]->free(db->tbl[0]);
+            db->tbl[0] = NULL;
+            if (closeCache(db) != 0)
             {
-               db->tbl->free(db->tbl);
-               if (closeCache(db) != 0)
-               {
-                  Kdb_unlock(&db->shmem_info->cache_rwlock);
-                  return PERS_COM_FAILURE;
-               }
+               Kdb_unlock(&db->shared->rwlock);
+               return PERS_COM_FAILURE;
+            }
+            db->sharedCache = NULL;
+            if(db->sharedCacheFd)
+            {
+               close(db->sharedCacheFd);
+               db->sharedCacheFd = -1;
+            }
+         }
+         else //not the last instance, just unmap shared cache and free the name
+         {
+            //release reference object
+            db->tbl[0]->free(db->tbl[0]);
+            db->tbl[0] = NULL;
+            freeKdbShmemPtr(db->sharedCache, PERS_CACHE_MEMSIZE);
+            db->sharedCache = NULL;
+            if(db->sharedCacheFd)
+            {
+               close(db->sharedCacheFd);
+               db->sharedCacheFd = -1;
             }
          }
       }
-      Kdb_unlock(&db->shmem_info->cache_rwlock);
+      //no cache exists
+      Kdb_unlock(&db->shared->rwlock);
 
 #ifdef __showTimeMeasurements
       clock_gettime(CLOCK_ID, &kdbStart);
 #endif
 
-      kissdb_state = KISSDB_close(&pLldbHandler->kissDb);
+      kdbState = KISSDB_close(&pLldbHandler->kissDb);
 
 #ifdef __showTimeMeasurements
       clock_gettime(CLOCK_ID, &kdbEnd);
 #endif
 
-      if (kissdb_state == 0)
+      if (kdbState == 0)
       {
          if (!lldb_handles_DeinitHandle(pLldbHandler->dbHandler))
+         {
             returnValue = PERS_COM_FAILURE;
+         }
       }
       else
       {
-         switch (kissdb_state)
+         switch (kdbState)
          {
-            case KISSDB_ERROR_UNMAP_SHM:
+            case KISSDB_ERROR_CLOSE_SHM:
             {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING("KISSDB_close: "); DLT_STRING("Could not unmap shared memory object, retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                       DLT_STRING("KISSDB_close: "); DLT_STRING("Could not close shared memory object, retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
                break;
             }
-            case KISSDB_ERROR_CLOSE_SHM:
+            default:
             {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING("KISSDB_close: "); DLT_STRING("Could not close shared memory object, retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                       DLT_STRING("KISSDB_close: "); DLT_STRING("Could not close database, retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
                break;
             }
-            default:
-               break;
          }
          returnValue = PERS_COM_FAILURE;
       }
    }
+
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(handlerDB); DLT_STRING(" retval=<"); DLT_INT(returnValue); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(handlerDB); DLT_STRING(" retval=<"); DLT_INT(returnValue); DLT_STRING(">"));
 
 #ifdef __showTimeMeasurements
    clock_gettime(CLOCK_ID, &writeEnd);
    writeDuration += getNsDuration(&writebackStart, &writebackEnd);
-   printf("Writeback to flash duration for %s => %f ms\n", pLldbHandler->dbPathname, (double)((double)writeDuration/NANO2MIL));
+   printf("Writeback to flash duration for %s => %f ms\n",
+          pLldbHandler->dbPathname, (double)((double)writeDuration/NANO2MIL));
    KdbDuration += getNsDuration(&kdbStart, &kdbEnd);
-   printf("KISSDB_close duration for %s => %f ms\n", pLldbHandler->dbPathname, (double)((double)KdbDuration/NANO2MIL));
+   printf("KISSDB_close duration for %s => %f ms\n", pLldbHandler->dbPathname,
+          (double)((double)KdbDuration/NANO2MIL));
    duration += getNsDuration(&writeStart, &writeEnd);
-   printf("Overall Close duration for %s => %f ms\n", pLldbHandler->dbPathname, (double)((double)duration/NANO2MIL));
+   printf("Overall Close duration for %s => %f ms\n", pLldbHandler->dbPathname,
+          (double)((double)duration/NANO2MIL));
 #endif
-   return returnValue;
-}
-
 
+#ifdef PFS_TEST
+   printf("END: pers_lldb_close for PID: %d \n", getpid());
+#endif
 
+   return returnValue;
+}
 
 /**
  * \writeback cache of RCT key-value database
@@ -385,48 +572,59 @@ sint_t pers_lldb_close(sint_t handlerDB)
  */
 static sint_t writeBackKissRCT(KISSDB* db, lldb_handler_s* pLldbHandler)
 {
-   int kissdb_state = 0;
+   char* metaKey;
+   char* ptr;
    int idx = 0;
-   sint_t returnValue = PERS_COM_SUCCESS;
-   //lldb_handler_s* pLldbHandler = NIL;
+   int kdbState = 0;
+   int32_t bytesDeleted = 0;
+   int32_t bytesWritten = 0;
    pers_lldb_cache_flag_e eFlag;
-   char* ptr;
    qnobj_t obj;
-   char tmp_key[PERS_RCT_MAX_LENGTH_RESOURCE_ID];
+   sint_t returnValue = PERS_COM_SUCCESS;
+
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("START writeback for RCT: "),
+           DLT_STRING(pLldbHandler->dbPathname));
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("START writeback for RCT: "), DLT_STRING(db->shmem_ht_name) );
+   setMemoryAddress(db->sharedCache, db->tbl[0]);
 
-   while (db->tbl->getnext(db->tbl, &obj, &idx) == true)
+   while (db->tbl[0]->getnext(db->tbl[0], &obj, &idx) == true)
    {
       ptr = obj.data;
       eFlag = (pers_lldb_cache_flag_e) *(int*) ptr;
       ptr += 2 * (sizeof(int));
-      (void) strncpy(tmp_key, obj.name, PERS_RCT_MAX_LENGTH_RESOURCE_ID);
+      metaKey = obj.name;
 
       //check how data should be persisted
       switch (eFlag)
       {
          case CachedDataDelete:  //data must be deleted from file
          {
-            kissdb_state = KISSDB_delete(&pLldbHandler->kissDb, tmp_key);
-            if (kissdb_state != 0)
+            kdbState = KISSDB_delete(&pLldbHandler->kissDb, metaKey, &bytesDeleted);
+            if (kdbState != 0)
             {
-               if (kissdb_state == 1)
+               if (kdbState == 1)
+               {
                   DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-                        DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: RCT key=<"); DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                          DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: RCT key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kdbState);
+                          DLT_STRING(">"));
+               }
                else
+               {
                   DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                        DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: RCT key=<");DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                          DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: RCT key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
+               }
             }
             break;
          }
          case CachedDataWrite:   //data must be written to file
          {
-            kissdb_state = KISSDB_put(&pLldbHandler->kissDb, tmp_key, ptr);
-            if (kissdb_state != 0)
+            kdbState = KISSDB_put(&pLldbHandler->kissDb, metaKey, ptr, sizeof(PersistenceConfigurationKey_s), &bytesWritten);
+            if (kdbState != 0)
+            {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: RCT key=<");DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error: Writing back to file failed with retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: RCT key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("Writing back to file failed with retval=<");
+                       DLT_INT(kdbState); DLT_STRING(">"));
+            }
             break;
          }
          default:
@@ -436,39 +634,40 @@ static sint_t writeBackKissRCT(KISSDB* db, lldb_handler_s* pLldbHandler)
       free(obj.data);
    }
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("END writeback for RCT: "), DLT_STRING(db->shmem_ht_name) );
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("END writeback for RCT: "),
+           DLT_STRING(pLldbHandler->dbPathname));
    return returnValue;
 }
 
 
 
 
-
-
-
 /**
- * \writeback cache of local DB key-value database
- * \return 0 for success, negative value otherway (see pers_error_codes.h)
+ * Write back the data in cache to database file
+ * @param db
+ * @param pLldbHandler
+ * @return 0 for success, negative value otherway (see pers_error_codes.h)
  */
 static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
 {
-   int kissdb_state = 0;
+   char* metaKey;
+   char* ptr;
+   Data_LocalDB_s insert = {{0},0};
+   int datasize = 0;
    int idx = 0;
-   sint_t returnValue = PERS_COM_SUCCESS;
-   //lldb_handler_s* pLldbHandler = NIL;
+   int kdbState = 0;
+   int32_t bytesDeleted = 0;
+   int32_t bytesWritten = 0;
    pers_lldb_cache_flag_e eFlag;
-   char* ptr;
    qnobj_t obj;
+   sint_t returnValue = PERS_COM_SUCCESS;
 
-   char tmp_key[PERS_DB_MAX_LENGTH_KEY_NAME];
-   Data_LocalDB_s insert = { { 0 } };
-   int datasize = 0;
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("START writeback for DB: "),
+           DLT_STRING(pLldbHandler->dbPathname));
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("START writeback for DB: "), DLT_STRING(db->shmem_ht_name) );
+   setMemoryAddress(db->sharedCache, db->tbl[0]);
 
-   while (db->tbl->getnext(db->tbl, &obj, &idx) == true)
+   while (db->tbl[0]->getnext(db->tbl[0], &obj, &idx) == true)
    {
       //get flag and datasize
       ptr = obj.data;
@@ -476,7 +675,7 @@ static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
       ptr += sizeof(int);
       datasize = *(int*) ptr; //pointer in obj.data to datasize
       ptr += sizeof(int);     //pointer in obj.data to data
-      (void) strncpy(tmp_key, obj.name, PERS_DB_MAX_LENGTH_KEY_NAME);
+      metaKey = obj.name;
 
       //check how data should be persisted
       switch (eFlag)
@@ -484,15 +683,21 @@ static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
          case CachedDataDelete:  //data must be deleted from file
          {
             //delete key-value pair from database file
-            kissdb_state = KISSDB_delete(&pLldbHandler->kissDb, tmp_key);
-            if (kissdb_state != 0)
+            kdbState = KISSDB_delete(&pLldbHandler->kissDb, metaKey, &bytesDeleted);
+            if (kdbState != 0)
             {
-               if (kissdb_state == 1)
+               if (kdbState == 1)
+               {
                   DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-                        DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"));
+                          DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kdbState);
+                          DLT_STRING(">"));
+               }
                else
+               {
                   DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                        DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<");DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"); DLT_STRING("Error Message: ");DLT_STRING(strerror(errno)));
+                          DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kdbState); DLT_STRING(">");
+                          DLT_STRING("Error Message: "); DLT_STRING(strerror(errno)));
+               }
             }
             break;
          }
@@ -500,11 +705,13 @@ static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
          {
             (void) memcpy(insert.m_data, ptr, datasize);
             insert.m_dataSize = datasize;
-
-            kissdb_state = KISSDB_put(&pLldbHandler->kissDb, tmp_key, &insert); //store data followed by datasize
-            if (kissdb_state != 0)
+            kdbState = KISSDB_put(&pLldbHandler->kissDb, metaKey, &insert, insert.m_dataSize, &bytesWritten); //store data followed by datasize
+            if (kdbState != 0)
+            {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: key=<");DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error: Writing back to file failed with retval=<"); DLT_INT(kissdb_state); DLT_STRING(">"); DLT_STRING("Error Message: ");DLT_STRING(strerror(errno)));
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("Writing back to file failed with retval=<");
+                       DLT_INT(kdbState); DLT_STRING(">"); DLT_STRING("Error Message: "); DLT_STRING(strerror(errno)));
+            }
             break;
          }
          default:
@@ -513,17 +720,12 @@ static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
       free(obj.name);
       free(obj.data);
    }
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("END writeback for DB: "), DLT_STRING(db->shmem_ht_name) );
+
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG, DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("END writeback for DB: "),
+           DLT_STRING(pLldbHandler->dbPathname));
    return returnValue;
 }
 
-
-
-
-
-
-
 /**
  * \brief write a key-value pair into database
  * \note : DB type is identified from dbPathname (based on extension)
@@ -537,15 +739,10 @@ static sint_t writeBackKissDB(KISSDB* db, lldb_handler_s* pLldbHandler)
  *
  * \return 0 for success, negative value otherway (see pers_error_codes.h)
  */
-sint_t pers_lldb_write_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const * key, str_t const * data,
-      sint_t dataSize)
+sint_t pers_lldb_write_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const* key, str_t const* data, sint_t dataSize)
 {
    sint_t eErrorCode = PERS_COM_SUCCESS;
 
-   //int i =0;
-   //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-   //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Datatest="); DLT_RAW(data,dataSize); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>"); DLT_STRING(" Data Size=<<"); DLT_INT(dataSize); DLT_STRING(">>..."));
-
    switch (ePurpose)
    {
       case PersLldbPurpose_DB:
@@ -555,7 +752,7 @@ sint_t pers_lldb_write_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t
       }
       case PersLldbPurpose_RCT:
       {
-         eErrorCode = SetDataInKissRCT(handlerDB, key, (PersistenceConfigurationKey_s const *) data);
+         eErrorCode = SetDataInKissRCT(handlerDB, key, (PersistenceConfigurationKey_s const*) data);
          break;
       }
       default:
@@ -579,8 +776,7 @@ sint_t pers_lldb_write_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t
  *
  * \return read size, or negative value in case of error (see pers_error_codes.h)
  */
-sint_t pers_lldb_read_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const * key, pstr_t dataBuffer_out,
-      sint_t bufSize)
+sint_t pers_lldb_read_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const* key, pstr_t dataBuffer_out, sint_t bufSize)
 {
    sint_t eErrorCode = PERS_COM_SUCCESS;
 
@@ -614,7 +810,7 @@ sint_t pers_lldb_read_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t
  * \param key               [in] key's name
  * \return size of the value corresponding to the key, or negative value in case of error (see pers_error_codes.h)
  */
-sint_t pers_lldb_get_key_size(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const * key)
+sint_t pers_lldb_get_key_size(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const* key)
 {
    sint_t eErrorCode = PERS_COM_SUCCESS;
 
@@ -645,7 +841,7 @@ sint_t pers_lldb_get_key_size(sint_t handlerDB, pers_lldb_purpose_e ePurpose, st
  *
  * \return 0 for success, negative value otherway (see pers_error_codes.h)
  */
-sint_t pers_lldb_delete_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const * key)
+sint_t pers_lldb_delete_key(sint_t handlerDB, pers_lldb_purpose_e ePurpose, str_t const* key)
 {
    sint_t eErrorCode = PERS_COM_SUCCESS;
 
@@ -738,29 +934,19 @@ sint_t pers_lldb_get_keys_list(sint_t handlerDB, pers_lldb_purpose_e ePurpose, p
          break;
       }
    }
-
    return eErrorCode;
 }
 
-//TODO add write through compatibility
 static sint_t DeleteDataFromKissDB(sint_t dbHandler, pconststr_t key)
 {
    bool_t bCanContinue = true;
-   sint_t delete_size = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
-   char m_data[sizeof(Data_LocalDB_s)] = {0};
-   pers_lldb_cache_flag_e eFlag;
-   void *val;
-   char *ptr;
-   int status = PERS_COM_FAILURE;
-   int datasize = 0;
-   Kdb_bool not_found = Kdb_false;
-   size_t size = 0;
-   Data_Cached_s data_cached = { 0 };
+   int kdbState = 0;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesDeleted = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key))
    {
@@ -769,135 +955,69 @@ static sint_t DeleteDataFromKissDB(sint_t dbHandler, pconststr_t key)
          bLocked = true;
          pLldbHandler = lldb_handles_FindInUseHandle(dbHandler);
          if (NIL == pLldbHandler)
+         {
             bCanContinue = false;
+         }
       }
    }
    else
+   {
       bCanContinue = false;
+   }
+
 
    if (bCanContinue)
    {
-      KISSDB* db = &pLldbHandler->kissDb;
-
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(db->shmem_ht_name) );
-
-      Kdb_wrlock(&db->shmem_info->cache_rwlock);
-
-      char tmp_key[PERS_DB_MAX_LENGTH_KEY_NAME];
-      (void) strncpy(tmp_key, key, PERS_DB_MAX_LENGTH_KEY_NAME);
-      data_cached.eFlag = CachedDataDelete;
-      data_cached.m_dataSize = 0;
-
-      //if cache not already created
-      if (db->shmem_info->cache_initialised == Kdb_false)
-      {
-         if (createCache(db) != 0)
-         {
-            Kdb_unlock(&db->shmem_info->cache_rwlock);
-            return PERS_COM_FAILURE;
-         }
-      }
-      else //open cache
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
       {
-         if (openCache(db) != 0)
-         {
-            Kdb_unlock(&db->shmem_info->cache_rwlock);
-            return PERS_COM_FAILURE;
-         }
+         bytesDeleted = deleteFromCache(&pLldbHandler->kissDb, (char*) key);
       }
-      val = db->tbl->get(db->tbl, tmp_key, &size);
-      if (NULL != val) //check if key to be deleted is in Cache
+      else //write through
       {
-         ptr = val;
-         eFlag = (pers_lldb_cache_flag_e) *(int*) ptr;
-         ptr += sizeof(int);
-         datasize = *(int*) ptr;
 
-         //Mark data in cache as deleted
-         if (eFlag != CachedDataDelete)
-         {
-            if (db->tbl->put(db->tbl, tmp_key, &data_cached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false) //do not store any data
-            {
-               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Failed to mark data in cache as deleted"));
-               delete_size = PERS_COM_ERR_NOT_FOUND;
-               not_found = Kdb_true;
-            }
-            else
-               delete_size = datasize;
-         }
-      }
-      else //check if key to be deleted is in database file
-      {
-         //get dataSize
-         status = KISSDB_get(&pLldbHandler->kissDb, tmp_key, m_data);
-         if (status == 0)
+         kdbState = KISSDB_delete(&pLldbHandler->kissDb, key, &bytesDeleted);
+         if (kdbState != 0)
          {
-            ptr = m_data;
-            ptr += PERS_DB_MAX_SIZE_KEY_DATA;
-            datasize = *(int*) ptr;
-            //put information about the key to be deleted in cache (deletion in file happens at system shutdown)
-            if (db->tbl->put(db->tbl, tmp_key, &data_cached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false)
+            if (kdbState == 1)
             {
-               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Failed to mark existing data as deleted"));
-               delete_size = PERS_COM_ERR_NOT_FOUND;
-            }
-            else
-               delete_size = datasize;
-         }
-         else
-         {
-            if (status == 1)
-            {
-               not_found = Kdb_true;
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("not found, retval=<"); DLT_INT(status); DLT_STRING(">"));
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kdbState);
+                       DLT_STRING(">"));
             }
             else
             {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get:  key=<"); DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(status); DLT_STRING(">"));
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kdbState); DLT_STRING(">");
+                       DLT_STRING("Error Message: "); DLT_STRING(strerror(errno)));
             }
          }
       }
-
-      if (not_found == Kdb_true) //key not found,
-         delete_size = PERS_COM_ERR_NOT_FOUND;
-      Kdb_unlock(&db->shmem_info->cache_rwlock);
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
 
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(delete_size); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("retval=<");
+           DLT_INT(bytesDeleted); DLT_STRING(">"));
 
-   return delete_size;
+   return bytesDeleted;
 }
 
-
-
-//TODO add write through compatibility
 static sint_t DeleteDataFromKissRCT(sint_t dbHandler, pconststr_t key)
 {
    bool_t bCanContinue = true;
-   sint_t delete_size = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
-   char m_data[sizeof(Data_LocalDB_s)] = {0};
-   pers_lldb_cache_flag_e eFlag;
-   void *val;
-   char *ptr;
-   int status = PERS_COM_FAILURE;
-   int datasize = 0;
-   Kdb_bool not_found = Kdb_false;
-   size_t size = 0;
-   Data_Cached_s data_cached = { 0 };
+   int kdbState = 0;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesDeleted = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key))
    {
@@ -906,123 +1026,67 @@ static sint_t DeleteDataFromKissRCT(sint_t dbHandler, pconststr_t key)
          bLocked = true;
          pLldbHandler = lldb_handles_FindInUseHandle(dbHandler);
          if (NIL == pLldbHandler)
+         {
             bCanContinue = false;
+         }
       }
    }
    else
+   {
       bCanContinue = false;
+   }
 
    if (bCanContinue)
    {
-      KISSDB* db = &pLldbHandler->kissDb;
-
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(db->shmem_ht_name) );
-
-      Kdb_wrlock(&db->shmem_info->cache_rwlock);
-
-      char tmp_key[PERS_RCT_MAX_LENGTH_RESOURCE_ID];
-      (void) strncpy(tmp_key, key, PERS_RCT_MAX_LENGTH_RESOURCE_ID);
-      data_cached.eFlag = CachedDataDelete;
-      data_cached.m_dataSize = 0;
-
-      //if cache not already created
-      if (db->shmem_info->cache_initialised == Kdb_false)
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
       {
-         if (createCache(db) != 0)
-         {
-            Kdb_unlock(&db->shmem_info->cache_rwlock);
-            return PERS_COM_FAILURE;
-         }
+         bytesDeleted = deleteFromCache(&pLldbHandler->kissDb, (char*) key);
       }
-      else //open cache
+      else //write through
       {
-         if (openCache(db) != 0)
-         {
-            Kdb_unlock(&db->shmem_info->cache_rwlock);
-            return PERS_COM_FAILURE;
-         }
-      }
-      //get dataSize
-      val = db->tbl->get(db->tbl, tmp_key, &size);
-      if (NULL != val) //check if key to be deleted is in Cache
-      {
-         ptr = val;
-         eFlag = (pers_lldb_cache_flag_e) *(int*) ptr;
-         ptr += sizeof(int);
-         datasize = *(int*) ptr;
-
-         //Mark data in cache as deleted
-         if (eFlag != CachedDataDelete)
+         kdbState = KISSDB_delete(&pLldbHandler->kissDb, key, &bytesDeleted);
+         if (kdbState != 0)
          {
-            if (db->tbl->put(db->tbl, tmp_key, &data_cached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false)
+            if (kdbState == 1)
             {
-               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Failed to mark RCT data in cache as deleted"));
-               delete_size = PERS_COM_ERR_NOT_FOUND;
-               not_found = Kdb_true;
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("not found in database file, retval=<"); DLT_INT(kdbState);
+                       DLT_STRING(">"));
             }
             else
-               delete_size = datasize;
-         }
-      }
-      else //check if key to be deleted is in database file
-      {
-         status = KISSDB_get(&pLldbHandler->kissDb, tmp_key, m_data);
-         if (status == 0)
-         {
-            //Data to be deleted is not in cache, but was found in local database
-            //put information about the key to be deleted in cache (deletion in file happens at system shutdown)
-            if (db->tbl->put(db->tbl, tmp_key, &data_cached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false)
             {
                DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Failed to mark existing RCT data as deleted"));
-               delete_size = PERS_COM_ERR_NOT_FOUND;
+                       DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_delete: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kdbState); DLT_STRING(">");
+                       DLT_STRING("Error Message: "); DLT_STRING(strerror(errno)));
             }
-            else
-               delete_size = sizeof(PersistenceConfigurationKey_s);
-         }
-         else
-         {
-            if (status == 1)
-            {
-               not_found = Kdb_true;
-               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("not found, retval=<"); DLT_INT(status); DLT_STRING(">"));
-            }
-            else
-               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get:  key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(status); DLT_STRING(">"));
          }
       }
-      if (not_found == Kdb_true)
-         delete_size = PERS_COM_ERR_NOT_FOUND;
-
-      Kdb_unlock(&db->shmem_info->cache_rwlock);
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
 
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-   DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(delete_size); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("handlerDB="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("retval=<");
+           DLT_INT(bytesDeleted); DLT_STRING(">"));
 
-   return delete_size;
+   return bytesDeleted;
 }
 
-
-
-//TODO add write through compatibility
 static sint_t GetAllKeysFromKissLocalDB(sint_t dbHandler, pstr_t buffer, sint_t size)
 {
    bool_t bCanContinue = true;
-   sint_t result = 0;
+   bool_t bLocked = false;
    bool_t bOnlySizeNeeded = (NIL == buffer);
    lldb_handler_s* pLldbHandler = NIL;
-   bool_t bLocked = false;
+   sint_t result = 0;
 
-  //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         //DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("buffer="); DLT_UINT((uint_t)buffer); DLT_STRING("size="); DLT_INT(size); DLT_STRING("..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+   DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("buffer="); DLT_UINT((uint_t)buffer); DLT_STRING("size="); DLT_INT(size));
 
    if (dbHandler >= 0)
    {
@@ -1038,7 +1102,8 @@ static sint_t GetAllKeysFromKissLocalDB(sint_t dbHandler, pstr_t buffer, sint_t
          else
          {
             if (PersLldbPurpose_DB != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
                result = PERS_COM_FAILURE;
             }
@@ -1055,34 +1120,38 @@ static sint_t GetAllKeysFromKissLocalDB(sint_t dbHandler, pstr_t buffer, sint_t
    if (bCanContinue)
    {
       if ((buffer != NIL) && (size > 0))
+      {
          (void) memset(buffer, 0, (size_t) size);
+      }
 
-      Kdb_wrlock(&pLldbHandler->kissDb.shmem_info->cache_rwlock);
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
       result = getListandSize(&pLldbHandler->kissDb, buffer, size, bOnlySizeNeeded, PersLldbPurpose_DB);
-      Kdb_unlock(&pLldbHandler->kissDb.shmem_info->cache_rwlock);
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
       if (result < 0)
+      {
          result = PERS_COM_FAILURE;
+      }
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         //DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("retval=<"); DLT_INT(result); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+   DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("retval=<"); DLT_INT(result); DLT_STRING(">"));
    return result;
 }
 
-
-//TODO add write through compatibility
 static sint_t GetAllKeysFromKissRCT(sint_t dbHandler, pstr_t buffer, sint_t size)
 {
    bool_t bCanContinue = true;
-   sint_t result = 0;
+   bool_t bLocked = false;
    bool_t bOnlySizeNeeded = (NIL == buffer);
    lldb_handler_s* pLldbHandler = NIL;
-   bool_t bLocked = false;
+   sint_t result = 0;
 
-  //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         //DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("buffer="); DLT_UINT((uint_t)buffer); DLT_STRING("size="); DLT_INT(size); DLT_STRING("..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+   DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("buffer="); DLT_UINT((uint_t)buffer); DLT_STRING("size="); DLT_INT(size));
 
    if (dbHandler >= 0)
    {
@@ -1098,7 +1167,8 @@ static sint_t GetAllKeysFromKissRCT(sint_t dbHandler, pstr_t buffer, sint_t size
          else
          {
             if (PersLldbPurpose_RCT != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
                result = PERS_COM_FAILURE;
             }
@@ -1115,34 +1185,41 @@ static sint_t GetAllKeysFromKissRCT(sint_t dbHandler, pstr_t buffer, sint_t size
    if (bCanContinue)
    {
       if ((buffer != NIL) && (size > 0))
+      {
          (void) memset(buffer, 0, (size_t) size);
-      Kdb_wrlock(&pLldbHandler->kissDb.shmem_info->cache_rwlock);
+      }
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
       result = getListandSize(&pLldbHandler->kissDb, buffer, size, bOnlySizeNeeded, PersLldbPurpose_RCT);
-      Kdb_unlock(&pLldbHandler->kissDb.shmem_info->cache_rwlock);
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
       if (result < 0)
+      {
          result = PERS_COM_FAILURE;
+      }
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         //DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("retval=<"); DLT_INT(result); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+   DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("retval=<"); DLT_INT(result); DLT_STRING(">"));
 
    return result;
 }
 
-
-//TODO add write through compatibility
 static sint_t SetDataInKissLocalDB(sint_t dbHandler, pconststr_t key, pconststr_t data, sint_t dataSize)
 {
    bool_t bCanContinue = true;
-   sint_t size_written = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
-   Data_Cached_s data_cached = { 0 };
+   Data_Cached_s dataCached = { 0 };
+   int kdbState = 0;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesWritten = PERS_COM_FAILURE;
+
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("size<<"); DLT_INT(dataSize); DLT_STRING(">> ..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("size<");
+           DLT_INT(dataSize); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key) && (NIL != data) && (dataSize > 0))
    {
@@ -1153,14 +1230,15 @@ static sint_t SetDataInKissLocalDB(sint_t dbHandler, pconststr_t key, pconststr_
          if (NIL == pLldbHandler)
          {
             bCanContinue = false;
-            size_written = PERS_COM_ERR_INVALID_PARAM;
+            bytesWritten = PERS_COM_ERR_INVALID_PARAM;
          }
          else
          {
             if (PersLldbPurpose_DB != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
-               size_written = PERS_COM_FAILURE;
+               bytesWritten = PERS_COM_FAILURE;
             }
          }
       }
@@ -1168,43 +1246,59 @@ static sint_t SetDataInKissLocalDB(sint_t dbHandler, pconststr_t key, pconststr_
    else
    {
       bCanContinue = false;
-      size_written = PERS_COM_ERR_INVALID_PARAM;
+      bytesWritten = PERS_COM_ERR_INVALID_PARAM;
    }
 
    if (bCanContinue)
    {
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(pLldbHandler->dbPathname) );
+      char* metaKey = (char*) key;
+      dataCached.eFlag = CachedDataWrite;
+      dataCached.m_dataSize = dataSize;
+      (void) memcpy(dataCached.m_data, data, (size_t) dataSize);
 
-      //TODO add write through (call KissDB_put)
-      char tmp_key[PERS_DB_MAX_LENGTH_KEY_NAME];
-      (void) strncpy(tmp_key, key, PERS_DB_MAX_LENGTH_KEY_NAME);
-      data_cached.eFlag = CachedDataWrite;
-      data_cached.m_dataSize = dataSize;
-      (void) memcpy(data_cached.m_data, data, (size_t) dataSize);
-      size_written = putToCache(&pLldbHandler->kissDb, dataSize, (char*) &tmp_key, &data_cached);
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
+      {
+         bytesWritten = putToCache(&pLldbHandler->kissDb, dataSize, (char*) metaKey, &dataCached);
+      }
+      else
+      {
+         if (KISSDB_OPEN_MODE_RDONLY != pLldbHandler->kissDb.shared->openMode)
+         {
+            kdbState = KISSDB_put(&pLldbHandler->kissDb, metaKey, dataCached.m_data, dataCached.m_dataSize, &bytesWritten);
+            if (kdbState != 0)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("WriteThrough to file failed with retval=<"); DLT_INT(bytesWritten); DLT_STRING(">"));
+            }
+         }
+      }
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
 
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("size<<"); DLT_INT(dataSize); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(size_written); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("size<");
+           DLT_INT(dataSize); DLT_STRING(">, "); DLT_STRING("retval=<"); DLT_INT(bytesWritten); DLT_STRING(">"));
 
-   return size_written;
+   return bytesWritten;
 }
 
-//TODO add write through compatibility
-static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s const * pConfig)
+static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s const* pConfig)
 {
    bool_t bCanContinue = true;
-   sint_t size_written = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
-   Data_Cached_RCT_s data_cached = { 0 };
+   Data_Cached_RCT_s dataCached = { 0 };
+   int kdbState = 0;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesWritten = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key) && (NIL != pConfig))
    {
@@ -1215,14 +1309,15 @@ static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceCon
          if (NIL == pLldbHandler)
          {
             bCanContinue = false;
-            size_written = PERS_COM_ERR_INVALID_PARAM;
+            bytesWritten = PERS_COM_ERR_INVALID_PARAM;
          }
          else
          {
             if (PersLldbPurpose_RCT != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
-               size_written = PERS_COM_FAILURE;
+               bytesWritten = PERS_COM_FAILURE;
             }
             /* to not use DLT while mutex locked */
          }
@@ -1231,42 +1326,59 @@ static sint_t SetDataInKissRCT(sint_t dbHandler, pconststr_t key, PersistenceCon
    else
    {
       bCanContinue = false;
-      size_written = PERS_COM_ERR_INVALID_PARAM;
+      bytesWritten = PERS_COM_ERR_INVALID_PARAM;
    }
    if (bCanContinue)
    {
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(pLldbHandler->dbPathname) );
-
-      //TODO add RCT write through (call KissDB_put)
       int dataSize = sizeof(PersistenceConfigurationKey_s);
-      char tmp_key[PERS_RCT_MAX_LENGTH_RESOURCE_ID];
-      (void) strncpy(tmp_key, key, PERS_RCT_MAX_LENGTH_RESOURCE_ID);
-      data_cached.eFlag = CachedDataWrite;
-      data_cached.m_dataSize = dataSize;
-      (void) memcpy(data_cached.m_data, pConfig, (size_t) dataSize);
-      size_written = putToCache(&pLldbHandler->kissDb, dataSize, (char*) &tmp_key, &data_cached);
+      char* metaKey = (char*) key;
+      dataCached.eFlag = CachedDataWrite;
+      dataCached.m_dataSize = dataSize;
+      (void) memcpy(dataCached.m_data, pConfig, (size_t) dataSize);
+
+
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
+      {
+         bytesWritten = putToCache(&pLldbHandler->kissDb, dataSize, (char*) metaKey, &dataCached);
+      }
+      else
+      {
+
+         if (KISSDB_OPEN_MODE_RDONLY != pLldbHandler->kissDb.shared->openMode)
+         {
+            kdbState = KISSDB_put(&pLldbHandler->kissDb, metaKey, dataCached.m_data, dataCached.m_dataSize, &bytesWritten);
+            if (kdbState != 0)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_put: RCT key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("WriteThrough to file failed with retval=<"); DLT_INT(bytesWritten); DLT_STRING(">"));
+            }
+         }
+      }
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
+
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(size_written); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("retval=<");
+           DLT_INT(bytesWritten); DLT_STRING(">"));
 
-   return size_written;
+   return bytesWritten;
 }
 
-
-//TODO add write through compatibility
 static sint_t GetKeySizeFromKissLocalDB(sint_t dbHandler, pconststr_t key)
 {
    bool_t bCanContinue = true;
-   sint_t size_read = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesRead = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">> ..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key))
    {
@@ -1277,14 +1389,15 @@ static sint_t GetKeySizeFromKissLocalDB(sint_t dbHandler, pconststr_t key)
          if (NIL == pLldbHandler)
          {
             bCanContinue = false;
-            size_read = PERS_COM_ERR_INVALID_PARAM;
+            bytesRead = PERS_COM_ERR_INVALID_PARAM;
          }
          else
          {
             if (PersLldbPurpose_DB != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
-               size_read = PERS_COM_FAILURE;
+               bytesRead = PERS_COM_FAILURE;
             }
          }
       }
@@ -1292,38 +1405,47 @@ static sint_t GetKeySizeFromKissLocalDB(sint_t dbHandler, pconststr_t key)
    else
    {
       bCanContinue = false;
-      size_read = PERS_COM_ERR_INVALID_PARAM;
+      bytesRead = PERS_COM_ERR_INVALID_PARAM;
    }
    if (bCanContinue)
    {
-      char tmp_key[PERS_DB_MAX_LENGTH_KEY_NAME];
-      (void) strncpy(tmp_key, key, PERS_DB_MAX_LENGTH_KEY_NAME);
-      size_read = getFromCache(&pLldbHandler->kissDb, &tmp_key, NULL, 0, true);
-      if (size_read == PERS_STATUS_KEY_NOT_IN_CACHE)
-         size_read = getFromDatabaseFile(&pLldbHandler->kissDb, &tmp_key, NULL, PersLldbPurpose_DB, 0, true);
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
+      {
+         bytesRead = getFromCache(&pLldbHandler->kissDb, (char*) key, NULL, 0, true);
+         if (bytesRead == PERS_STATUS_KEY_NOT_IN_CACHE)
+         {
+            bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, NULL, 0);
+         }
+      }
+      else
+      {
+         bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, NULL, 0);
+      }
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
-   DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(size_read); DLT_STRING(">"));
+   }
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("retval=<");
+           DLT_INT(bytesRead); DLT_STRING(">"));
 
-   return size_read;
+   return bytesRead;
 }
 
-
-
-
-//TODO add write through compatibility
 /* return no of bytes read, or negative value in case of error */
 static sint_t GetDataFromKissLocalDB(sint_t dbHandler, pconststr_t key, pstr_t buffer_out, sint_t bufSize)
 {
    bool_t bCanContinue = true;
-   sint_t size_read = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesRead = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("bufsize=<<"); DLT_INT(bufSize); DLT_STRING(">> ... "));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("bufsize=<");
+           DLT_INT(bufSize); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key) && (NIL != buffer_out) && (bufSize > 0))
    {
@@ -1334,14 +1456,15 @@ static sint_t GetDataFromKissLocalDB(sint_t dbHandler, pconststr_t key, pstr_t b
          if (NIL == pLldbHandler)
          {
             bCanContinue = false;
-            size_read = PERS_COM_ERR_INVALID_PARAM;
+            bytesRead = PERS_COM_ERR_INVALID_PARAM;
          }
          else
          {
             if (PersLldbPurpose_DB != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
-               size_read = PERS_COM_FAILURE;
+               bytesRead = PERS_COM_FAILURE;
             }
             /* to not use DLT while mutex locked */
          }
@@ -1350,42 +1473,47 @@ static sint_t GetDataFromKissLocalDB(sint_t dbHandler, pconststr_t key, pstr_t b
    else
    {
       bCanContinue = false;
-      size_read = PERS_COM_ERR_INVALID_PARAM;
+      bytesRead = PERS_COM_ERR_INVALID_PARAM;
    }
 
    if (bCanContinue)
    {
-
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(pLldbHandler->dbPathname) );
-
-      char tmp_key[PERS_DB_MAX_LENGTH_KEY_NAME];
-      (void) strncpy(tmp_key, key, PERS_DB_MAX_LENGTH_KEY_NAME);
-      size_read = getFromCache(&pLldbHandler->kissDb, &tmp_key, buffer_out, bufSize, false);
-      //if key is not already in cache
-      if (size_read == PERS_STATUS_KEY_NOT_IN_CACHE)
-         size_read = getFromDatabaseFile(&pLldbHandler->kissDb, &tmp_key, buffer_out, PersLldbPurpose_DB, bufSize,
-               false);
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
+      {
+         bytesRead = getFromCache(&pLldbHandler->kissDb, (char*) key, buffer_out, bufSize, false);
+         //if key is not already in cache
+         if (bytesRead == PERS_STATUS_KEY_NOT_IN_CACHE)
+         {
+            bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, buffer_out, bufSize);
+         }
+      }
+      else //write through mode -> only read from file
+      {
+         bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, buffer_out, bufSize);
+      }
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("bufsize=<<"); DLT_INT(bufSize); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(size_read); DLT_STRING(">"));
-   return size_read;
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("bufsize=<");
+           DLT_INT(bufSize); DLT_STRING(">, "); DLT_STRING("retval=<"); DLT_INT(bytesRead); DLT_STRING(">"));
+   return bytesRead;
 }
 
-
-//TODO add write through compatibility
 static sint_t GetDataFromKissRCT(sint_t dbHandler, pconststr_t key, PersistenceConfigurationKey_s* pConfig)
 {
    bool_t bCanContinue = true;
-   sint_t size_read = PERS_COM_FAILURE;
-   lldb_handler_s* pLldbHandler = NIL;
    bool_t bLocked = false;
+   lldb_handler_s* pLldbHandler = NIL;
+   sint_t bytesRead = PERS_COM_FAILURE;
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">> ..."));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">"));
 
    if ((dbHandler >= 0) && (NIL != key) && (NIL != pConfig))
    {
@@ -1396,14 +1524,15 @@ static sint_t GetDataFromKissRCT(sint_t dbHandler, pconststr_t key, PersistenceC
          if (NIL == pLldbHandler)
          {
             bCanContinue = false;
-            size_read = PERS_COM_ERR_INVALID_PARAM;
+            bytesRead = PERS_COM_ERR_INVALID_PARAM;
          }
          else
          {
             if (PersLldbPurpose_RCT != pLldbHandler->ePurpose)
-            {/* this would be very bad */
+            {
+               /* this would be very bad */
                bCanContinue = false;
-               size_read = PERS_COM_FAILURE;
+               bytesRead = PERS_COM_FAILURE;
             }
             /* to not use DLT while mutex locked */
          }
@@ -1412,34 +1541,39 @@ static sint_t GetDataFromKissRCT(sint_t dbHandler, pconststr_t key, PersistenceC
    else
    {
       bCanContinue = false;
-      size_read = PERS_COM_ERR_INVALID_PARAM;
+      bytesRead = PERS_COM_ERR_INVALID_PARAM;
    }
 
    //read RCT
    if (bCanContinue)
    {
-      //DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-      //         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Working on DB: "), DLT_STRING(pLldbHandler->dbPathname) );
-
-      char tmp_key[PERS_RCT_MAX_LENGTH_RESOURCE_ID];
-      (void) strncpy(tmp_key, key, PERS_RCT_MAX_LENGTH_RESOURCE_ID);
-
-      size_read = getFromCache(&pLldbHandler->kissDb, &tmp_key, pConfig, sizeof(PersistenceConfigurationKey_s), false);
-      if (size_read == PERS_STATUS_KEY_NOT_IN_CACHE)
-         size_read = getFromDatabaseFile(&pLldbHandler->kissDb, &tmp_key, pConfig, PersLldbPurpose_RCT,
-               sizeof(PersistenceConfigurationKey_s), false);
+      Kdb_wrlock(&pLldbHandler->kissDb.shared->rwlock);
+      if ( KISSDB_WRITE_MODE_WC == pLldbHandler->kissDb.shared->writeMode)
+      {
+         bytesRead = getFromCache(&pLldbHandler->kissDb, (char*) key, pConfig, sizeof(PersistenceConfigurationKey_s), false);
+         if (bytesRead == PERS_STATUS_KEY_NOT_IN_CACHE)
+         {
+            bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, pConfig, sizeof(PersistenceConfigurationKey_s));
+         }
+      }
+      else
+      {
+         bytesRead = getFromDatabaseFile(&pLldbHandler->kissDb, (char*) key, pConfig, sizeof(PersistenceConfigurationKey_s));
+      }
+      Kdb_unlock(&pLldbHandler->kissDb.shared->rwlock);
    }
    if (bLocked)
+   {
       (void) lldb_handles_Unlock();
+   }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<<"); DLT_STRING(key); DLT_STRING(">>, "); DLT_STRING("retval=<"); DLT_INT(size_read); DLT_STRING(">"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler="); DLT_INT(dbHandler); DLT_STRING("key=<"); DLT_STRING(key); DLT_STRING(">, "); DLT_STRING("retval=<");
+           DLT_INT(bytesRead); DLT_STRING(">"));
 
-   return size_read;
+   return bytesRead;
 }
 
-
-
 static bool_t lldb_handles_Lock(void)
 {
    bool_t bEverythingOK = true;
@@ -1448,7 +1582,7 @@ static bool_t lldb_handles_Lock(void)
    {
       bEverythingOK = false;
       DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("pthread_mutex_lock failed with error=<"); DLT_INT(siErr); DLT_STRING(">"));
+              DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("pthread_mutex_lock failed with error=<"); DLT_INT(siErr); DLT_STRING(">"));
    }
    return bEverythingOK;
 }
@@ -1462,7 +1596,7 @@ static bool_t lldb_handles_Unlock(void)
    {
       bEverythingOK = false;
       DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-            DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("pthread_mutex_unlock failed with error=<"); DLT_INT(siErr); DLT_STRING(">"));
+              DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("pthread_mutex_unlock failed with error=<"); DLT_INT(siErr); DLT_STRING(">"));
    }
    return bEverythingOK;
 }
@@ -1493,8 +1627,9 @@ static lldb_handler_s* lldb_handles_FindInUseHandle(sint_t dbHandler)
       }
    }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING((NIL!=pHandler) ? "Found handler <" : "ERROR can't find handler <"); DLT_INT(dbHandler); DLT_STRING(">"); DLT_STRING((NIL!=pHandler) ? (dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "in static area" : "in dynamic list") : ""));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING((NIL!=pHandler) ? "Found handler <" : "ERROR can't find handler <"); DLT_INT(dbHandler); DLT_STRING(">");
+           DLT_STRING((NIL!=pHandler) ? (dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "in static area" : "in dynamic list") : ""));
 
    return pHandler;
 }
@@ -1511,6 +1646,7 @@ static lldb_handler_s* lldb_handles_FindAvailableHandle(void)
    {
       if (!g_sHandlers.asStaticHandles[siIndex].bIsAssigned)
       {
+         //INITIALIZE KISSDB struct
          /* index setting should be done only once at the initialization of the static array
           * Anyway, doing it here is more consistent  */
          g_sHandlers.asStaticHandles[siIndex].dbHandler = siIndex;
@@ -1529,8 +1665,7 @@ static lldb_handler_s* lldb_handles_FindAvailableHandle(void)
       if (NIL == psListElemNew)
       {
          bCanContinue = false;
-         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-               DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("malloc failed"));
+         DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("malloc failed"));
       }
       else
       {
@@ -1597,14 +1732,15 @@ static lldb_handler_s* lldb_handles_FindAvailableHandle(void)
       }
    }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING((NIL!=pHandler) ? "Found availble handler <" : "ERROR can't find available handler <"); DLT_INT((NIL!=pHandler) ? pHandler->dbHandler : (-1)); DLT_STRING(">"); DLT_STRING((NIL!=pHandler) ? (pHandler->dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "in static area" : "in dynamic list") : ""));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING((NIL!=pHandler) ? "Found availble handler <" : "ERROR can't find available handler <");
+           DLT_INT((NIL!=pHandler) ? pHandler->dbHandler : (-1)); DLT_STRING(">");
+           DLT_STRING((NIL!=pHandler) ? (pHandler->dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "in static area" : "in dynamic list") : ""));
 
    return pHandler;
 }
 
-static void lldb_handles_InitHandle(lldb_handler_s* psHandle_inout, pers_lldb_purpose_e ePurpose,
-      str_t const * dbPathname)
+static void lldb_handles_InitHandle(lldb_handler_s* psHandle_inout, pers_lldb_purpose_e ePurpose, str_t const* dbPathname)
 {
    psHandle_inout->bIsAssigned = true;
    psHandle_inout->ePurpose = ePurpose;
@@ -1669,43 +1805,40 @@ static bool_t lldb_handles_DeinitHandle(sint_t dbHandler)
       }
    }
 
-  DLT_LOG(persComLldbDLTCtx, DLT_LOG_INFO,
-         DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler=<"); DLT_INT(dbHandler); DLT_STRING("> "); DLT_STRING(bEverythingOK ? (dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "deinit handler in static area" : "deinit handler in dynamic list") : "ERROR - handler not found"));
+   DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+           DLT_STRING(LT_HDR); DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("dbHandler=<"); DLT_INT(dbHandler); DLT_STRING("> ");
+           DLT_STRING(bEverythingOK ? (dbHandler <= PERS_LLDB_MAX_STATIC_HANDLES ? "deinit handler in static area" : "deinit handler in dynamic list") : "ERROR - handler not found"));
 
    return bEverythingOK;
 }
 
-
-
-sint_t getFromCache(KISSDB* db, void* tmp_key, void* readBuffer, sint_t bufsize, bool_t sizeOnly)
+sint_t getFromCache(KISSDB* db, void* metaKey, void* readBuffer, sint_t bufsize, bool_t sizeOnly)
 {
-   Kdb_bool cache_empty, key_deleted, key_not_found;
-   key_deleted = cache_empty = key_not_found = Kdb_false;
-   sint_t size_read = 0;
-   size_t size = 0;
-   int datasize = 0;
    char* ptr;
+   int datasize = 0;
+   Kdb_bool cacheEmpty, keyDeleted, keyNotFound;
    pers_lldb_cache_flag_e eFlag;
+   sint_t bytesRead = 0;
+   size_t size = 0;
+   void* val;
 
-   //if cache not already created
-   Kdb_wrlock(&db->shmem_info->cache_rwlock);
+   keyDeleted = cacheEmpty = keyNotFound = Kdb_false;
 
-   if (db->shmem_info->cache_initialised == Kdb_true)
+   //if cache already created
+   if (db->shared->cacheCreated == Kdb_true)
    {
-      //open existing cache in existing shared memory
-      if (db->shmem_cached_fd <= 0)
+      if (openCache(db) != 0)
       {
-         if (openCache(db) != 0)
-         {
-            Kdb_unlock(&db->shmem_info->cache_rwlock);
-            return PERS_COM_FAILURE;
-         }
+         return PERS_COM_FAILURE;
       }
-      void* val = db->tbl->get(db->tbl, tmp_key, &size);
+
+      setMemoryAddress(db->sharedCache, db->tbl[0]);
+
+      val = db->tbl[0]->get(db->tbl[0], metaKey, &size);
       if (val == NULL)
       {
-         size_read = PERS_COM_ERR_NOT_FOUND;
-         key_not_found = Kdb_true;
+         bytesRead = PERS_COM_ERR_NOT_FOUND;
+         keyNotFound = Kdb_true;
       }
       else
       {
@@ -1719,112 +1852,89 @@ sint_t getFromCache(KISSDB* db, void* tmp_key, void* readBuffer, sint_t bufsize,
             ptr = ptr + sizeof(pers_lldb_cache_flag_e);
             datasize = *(int*) ptr;
             ptr = ptr + sizeof(int); //move pointer to beginning of data
-            size_read = datasize;
+            bytesRead = datasize;
 
             //get data if needed
             if (!sizeOnly)
             {
                if (bufsize < datasize)
                {
-                  Kdb_unlock(&db->shmem_info->cache_rwlock);
                   return PERS_COM_FAILURE;
                }
                else
+               {
                   (void) memcpy(readBuffer, ptr, datasize);
+               }
             }
          }
          else
          {
-            size_read = PERS_COM_ERR_NOT_FOUND;
-            key_deleted = Kdb_true;
+            bytesRead = PERS_COM_ERR_NOT_FOUND;
+            keyDeleted = Kdb_true;
          }
          free(val);
       }
    }
    else
-      cache_empty = Kdb_true;
+   {
+      cacheEmpty = Kdb_true;
+   }
 
    //only read from file if key was not found in cache and if key was not marked as deleted in cache
-   if ((cache_empty == Kdb_true && key_deleted == Kdb_false) || key_not_found == Kdb_true)
+   if ((cacheEmpty == Kdb_true && keyDeleted == Kdb_false) || keyNotFound == Kdb_true)
    {
-      Kdb_unlock(&db->shmem_info->cache_rwlock);
       return PERS_STATUS_KEY_NOT_IN_CACHE; //key not found in cache
    }
    else
    {
-      Kdb_unlock(&db->shmem_info->cache_rwlock);
-      return size_read;
+      return bytesRead;
    }
 }
 
-
-
-sint_t getFromDatabaseFile(KISSDB* db, void* tmp_key, void* readBuffer, pers_lldb_purpose_e purpose, sint_t bufsize,
-      bool_t sizeOnly)
+sint_t getFromDatabaseFile(KISSDB* db, void* metaKey, void* readBuffer, sint_t bufsize)
 {
-   sint_t size_read = 0;
-   int datasize = 0;
-   char* ptr;
-   char m_data[sizeof(Data_LocalDB_s)] = { 0 }; //temporary buffer that gets filled with read in KISSDB_get
+   int kdbState = 0;
+   sint_t bytesRead = 0;
+   uint32_t size = 0;
 
-   int kissdb_status = KISSDB_get(db, tmp_key, m_data);
-   if (kissdb_status == 0)
+   kdbState  = KISSDB_get(db, metaKey, readBuffer, bufsize, &size);
+   if (kdbState == 0)
    {
-      if (purpose == PersLldbPurpose_DB)
-      {
-         ptr = m_data;
-         ptr += PERS_DB_MAX_SIZE_KEY_DATA;
-         datasize = *(int*) ptr;
-         if (!sizeOnly)
-         {
-            if (bufsize < datasize)
-               return PERS_COM_FAILURE;
-            else
-               (void) memcpy(readBuffer, m_data, datasize);
-         }
-         size_read = datasize;
-      }
-      else
-      {
-         if (!sizeOnly)
-         {
-            if (bufsize < datasize)
-               return PERS_COM_FAILURE;
-            else
-               (void) memcpy(readBuffer, m_data, sizeof(PersistenceConfigurationKey_s));
-         }
-         size_read = sizeof(PersistenceConfigurationKey_s);
-      }
+      bytesRead = size;
    }
    else
    {
-      if (kissdb_status == 1)
+      if (kdbState == 1)
       {
          DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
-               DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("not found, retval=<"); DLT_INT(kissdb_status); DLT_STRING(">"));
-         size_read = PERS_COM_ERR_NOT_FOUND;
+                 DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("not found, retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
+         bytesRead = PERS_COM_ERR_NOT_FOUND;
       }
       else
       {
          DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-               DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get:  key=<"); DLT_STRING(tmp_key); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kissdb_status); DLT_STRING(">"));
+                 DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("Error with retval=<"); DLT_INT(kdbState); DLT_STRING(">"));
       }
-      size_read = PERS_COM_ERR_NOT_FOUND;
+      bytesRead = PERS_COM_ERR_NOT_FOUND;
    }
-   return size_read;
+   return bytesRead;
 }
 
-sint_t putToCache(KISSDB* db, sint_t dataSize, char* tmp_key, void* insert_cached_data)
+sint_t putToCache(KISSDB* db, sint_t dataSize, char* metaKey, void* cachedData)
 {
-   sint_t size_written = 0;
-   Kdb_wrlock(&db->shmem_info->cache_rwlock);
+   sint_t bytesWritten = 0;
+
+   //DO NOT ALLOW WRITING TO CACHE IF DATABASE IS OPENED IN READONLY MODE
+   if(KISSDB_OPEN_MODE_RDONLY == db->shared->openMode )
+   {
+      return PERS_COM_ERR_READONLY;
+   }
 
    //if cache not already created
-   if (db->shmem_info->cache_initialised == Kdb_false)
+   if (db->shared->cacheCreated == Kdb_false)
    {
       if (createCache(db) != 0)
       {
-         Kdb_unlock(&db->shmem_info->cache_rwlock);
          return PERS_COM_FAILURE;
       }
    }
@@ -1832,110 +1942,295 @@ sint_t putToCache(KISSDB* db, sint_t dataSize, char* tmp_key, void* insert_cache
    {
       if (openCache(db) != 0)
       {
-         Kdb_unlock(&db->shmem_info->cache_rwlock);
          return PERS_COM_FAILURE;
       }
    }
-
+   // update db->sharedCache pointer (process adress range mapping can be different after remap) (use
+   //printf("setMemoryAddress(db->sharedCache, db->tbl[0] = %p \n", db->sharedCache );
+   setMemoryAddress(db->sharedCache, db->tbl[0]); //address to first hashtable
    //put in cache
-   if (db->tbl->put(db->tbl, tmp_key, insert_cached_data,
-         sizeof(pers_lldb_cache_flag_e) + sizeof(int) + (size_t) dataSize) == false) //store flag , datasize and data as value in cache
+   if (db->tbl[0]->put(db->tbl[0], metaKey, cachedData, sizeof(pers_lldb_cache_flag_e) + sizeof(int) + (size_t) dataSize) ==
+         false) //store flag , datasize and data as value in cache
    {
-      size_written = PERS_COM_FAILURE;
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-                    DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Error: Failed to put data into cache"));
+      bytesWritten = PERS_COM_FAILURE;
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Failed to put data into cache: "); DLT_STRING(strerror(errno)));
+
+#if 0
+      int k = 0;
+      //if additional caches were created by another process -> get referemnce to them and init the local tbl struct
+      if(db->cacheReferenced < db->shared->cacheCount)
+      {
+         printf("additional caches found! \n");
+         //init local tbl2 array (internally a malloc occurs)
+         for(k=1; k < db->shared->cacheCount; k++ )
+         {
+            printf("qhasharr init cache no.= %d with zero \n",k);
+            db->tbl[k] = qhasharr(db->sharedCache + (k * PERS_CACHE_MEMSIZE) , 0);
+            db->cacheReferenced++;
+         }
+      }
+
+      //reset addresses for all caches mapped to this process space
+      for(k=0; k <  db->shared->cacheCount; k++ )
+      {
+         printf("setMemoryAddress  k= %d --  putToCache ptr: %p \n", k, db->sharedCache + (k * PERS_CACHE_MEMSIZE));
+         setMemoryAddress(db->sharedCache + (k * PERS_CACHE_MEMSIZE ), db->tbl[k]);
+      }
+
+      int putOk = 0;
+      k=0;
+      //try to insert data until empty slot or same key is found in all of the caches
+      while (k < db->shared->cacheCount) //store flag , datasize and data as value in cache
+      {
+         printf("start while k = %d, cacheCount= %d\n", k, db->shared->cacheCount);
+         if( db->tbl[k]->put(db->tbl[k], metaKey, cachedData, sizeof(pers_lldb_cache_flag_e) + sizeof(int) + (size_t) dataSize) == true)
+         {
+            putOk = 1;
+            printf("INSERT OK \n");
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+                                          DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("INSERT INTO Cache Nr: "); DLT_INT(k); DLT_STRING("worked : "));
+            break;
+         }
+         else
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                              DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("INSERT INTO Cache Nr: "); DLT_INT(k); DLT_STRING("failed : ");  DLT_STRING(strerror(errno)));
+         }
+         printf("end while k = %d \n", k);
+         k++;
+      }
+
+
+
+      //if all caches are full -> add new cache and insert data here
+      if (putOk == 0)
+      {
+         printf("data->maxslots 1 = %d \n", db->tbl[0]->data->maxslots);
+         printf("start adding new cache \n");
+         addCache(db); //add additional cache
+         printf("end  adding new cache \n");
+         printf("data->maxslots 2 = %d \n", db->tbl[0]->data->maxslots);
+
+         printf("Put not ok -> try to use added cache no. = %d \n", db->shared->cacheCount -1);
+
+         if (db->tbl[db->shared->cacheCount - 1]->put(db->tbl[db->shared->cacheCount - 1], metaKey, cachedData,
+               sizeof(pers_lldb_cache_flag_e) + sizeof(int) + (size_t) dataSize) ==  false) //store flag , datasize and data as value in cache
+         {
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                  DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("INSERT NEW DATA INTO RESIZE OF CACHE FAILED :  "); DLT_STRING(strerror(errno)));
+
+         }
+         else
+            DLT_LOG(persComLldbDLTCtx, DLT_LOG_DEBUG,
+                  DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("INSERT NEW DATA INTO RESIZE OF CACHE WORKS : "));
+      }
+      printf("END ----------- \n\n");
+#endif
    }
    else
-      size_written = dataSize;
-
-   Kdb_unlock(&db->shmem_info->cache_rwlock);
-   return size_written;
+   {
+      bytesWritten = dataSize; // return only size of data that has to be stored
+   }
+   return bytesWritten;
 }
 
 
 
+sint_t deleteFromCache(KISSDB* db, char* metaKey)
+{
+   char* ptr;
+   Data_Cached_s dataCached = { 0 };
+   int datasize = 0;
+   int status = PERS_COM_FAILURE;
+   Kdb_bool found = Kdb_true;
+   pers_lldb_cache_flag_e eFlag;
+   sint_t bytesDeleted = 0;
+   size_t size = 0;
+   void* val;
+
+   //DO NOT ALLOW WRITING TO CACHE IF DATABASE IS OPENED IN READONLY MODE
+   if (KISSDB_OPEN_MODE_RDONLY != db->shared->openMode)
+   {
+      dataCached.eFlag = CachedDataDelete;
+      dataCached.m_dataSize = 0;
+
+      //if cache not already created
+      if (db->shared->cacheCreated == Kdb_false)
+      {
+         if (createCache(db) != 0)
+         {
+            return PERS_COM_FAILURE;
+         }
+      }
+      else //open cache
+      {
+         if (openCache(db) != 0)
+         {
+            return PERS_COM_FAILURE;
+         }
+      }
+
+      setMemoryAddress(db->sharedCache, db->tbl[0]);
+
+      val = db->tbl[0]->get(db->tbl[0], metaKey, &size);
+      if (NULL != val) //check if key to be deleted is in Cache
+      {
+         ptr = val;
+         eFlag = (pers_lldb_cache_flag_e) *(int*) ptr;
+         ptr += sizeof(int);
+         datasize = *(int*) ptr;
+
+         //Mark data in cache as deleted
+         if (eFlag != CachedDataDelete)
+         {
+            if (db->tbl[0]->put(db->tbl[0], metaKey, &dataCached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false) //do not store any data
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Failed to mark data in cache as deleted"));
+               bytesDeleted = PERS_COM_ERR_NOT_FOUND;
+               found = Kdb_false;
+            }
+            else
+            {
+               bytesDeleted = datasize;
+            }
+         }
+      }
+      else //check if key to be deleted is in database file
+      {
+         //get dataSize
+         uint32_t size;
+         status = KISSDB_get(db, metaKey, NULL, 0, &size);
+         if (status == 0)
+         {
+            if (db->tbl[0]->put(db->tbl[0], metaKey, &dataCached, sizeof(pers_lldb_cache_flag_e) + sizeof(int)) == false)
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Failed to mark existing data as deleted"));
+               bytesDeleted = PERS_COM_ERR_NOT_FOUND;
+            }
+            else
+            {
+               bytesDeleted = size;
+            }
+         }
+         else
+         {
+            if (status == 1)
+            {
+               found = Kdb_false;
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_WARN,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get: key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("not found, retval=<"); DLT_INT(status); DLT_STRING(">"));
+            }
+            else
+            {
+               DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
+                     DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("KISSDB_get:  key=<"); DLT_STRING(metaKey); DLT_STRING(">, "); DLT_STRING("failed with retval=<"); DLT_INT(status); DLT_STRING(">"));
+            }
+         }
+      }
+
+      if (found == Kdb_false)
+      {
+         bytesDeleted = PERS_COM_ERR_NOT_FOUND;
+      }
+   }
+   else
+   {
+      bytesDeleted = PERS_COM_ERR_READONLY;
+   }
+   return bytesDeleted;
+}
+
 
 
 sint_t getListandSize(KISSDB* db, pstr_t buffer, sint_t size, bool_t bOnlySizeNeeded, pers_lldb_purpose_e purpose)
 {
-   KISSDB_Iterator dbi;
-   int keycount_file = 0, keycount_cache = 0, result = 0, x = 0, idx = 0, max = 0, used = 0, obj_count, keylength = 0;
+   char* memory = NULL;
+   char* ptr;
    char** tmplist = NULL;
+   int keyCountFile = 0, keyCountCache = 0, result = 0, x = 0, idx = 0, max = 0, used = 0, objCount = 0;
+   KISSDB_Iterator dbi;
+   pers_lldb_cache_flag_e eFlag;
+   qhasharr_t* tbl;
    qnobj_t obj;
    sint_t availableSize = size;
-   char* ptr;
-   char* memory = NULL;
    void* pt;
-   pers_lldb_cache_flag_e eFlag;
 
-   if (purpose == PersLldbPurpose_RCT)
-      keylength = PERS_RCT_MAX_LENGTH_RESOURCE_ID;
-   else
-      keylength = PERS_DB_MAX_LENGTH_KEY_NAME;
+   int keylength = (purpose == PersLldbPurpose_RCT) ? PERS_RCT_MAX_LENGTH_RESOURCE_ID : PERS_DB_MAX_LENGTH_KEY_NAME;
+   char kbuf[PERS_DB_MAX_LENGTH_KEY_NAME];
 
    //open existing cache if present and look for keys
-   if (db->shmem_info->cache_initialised == Kdb_true)
+   if (db->shared->cacheCreated == Kdb_true)
    {
       if (openCache(db) != 0)
       {
-         Kdb_unlock(&db->shmem_info->cache_rwlock);
          return PERS_COM_FAILURE;
       }
       else
       {
-         obj_count = db->tbl->size(db->tbl, &max, &used);
-         if (obj_count > 0)
+         setMemoryAddress(db->sharedCache, db->tbl[0]);
+
+         objCount = db->tbl[0]->size(db->tbl[0], &max, &used);
+         if (objCount > 0)
          {
-            tmplist = malloc(sizeof(char*) * obj_count);
+            tmplist = malloc(sizeof(char*) * objCount);
             if (tmplist != NULL)
             {
-               while (db->tbl->getnext(db->tbl, &obj, &idx) == true)
+               while (db->tbl[0]->getnext(db->tbl[0], &obj, &idx) == true)
                {
+                  size_t keyLen = strlen(obj.name);
                   pt = obj.data;
                   eFlag = (pers_lldb_cache_flag_e) *(int*) pt;
                   if (eFlag != CachedDataDelete)
                   {
-                     tmplist[keycount_cache] = (char*) malloc(strlen(obj.name) + 1);
-                     (void) strncpy(tmplist[keycount_cache], obj.name, strlen(obj.name));
-                     ptr = tmplist[keycount_cache];
-                     ptr[strlen(obj.name)] = '\0';
-                     keycount_cache++;
+                     tmplist[keyCountCache] = (char*) malloc(keyLen + 1);
+                     (void) strncpy(tmplist[keyCountCache], obj.name, keyLen);
+                     ptr = tmplist[keyCountCache];
+                     ptr[keyLen] = '\0';
+                     keyCountCache++;
                   }
                }
             }
             else
+            {
                return PERS_COM_ERR_MALLOC;
+            }
          }
       }
    }
 
    //look for keys in database file
+   //Initialise database iterator
    KISSDB_Iterator_init(db, &dbi);
-   char kbuf[keylength];
-
    //get number of keys, stored in database file
    while (KISSDB_Iterator_next(&dbi, &kbuf, NULL) > 0)
-      keycount_file++;
+   {
+      keyCountFile++;
+   }
 
-   if ((keycount_cache + keycount_file) > 0)
+   if ((keyCountCache + keyCountFile) > 0)
    {
-      int memsize = qhasharr_calculate_memsize(keycount_cache + keycount_file);
+      int memsize = qhasharr_calculate_memsize(keyCountCache + keyCountFile);
       //create hashtable that stores the list of keys without duplicates
       memory = malloc(memsize);
       if (memory != NULL)
       {
          memset(memory, 0, memsize);
-         qhasharr_t *tbl = qhasharr(memory, memsize);
+         tbl = qhasharr(memory, memsize);
          if (tbl == NULL)
+         {
             return PERS_COM_ERR_MALLOC;
-
+         }
          //put keys in cache to a hashtable
-         for (x = 0; x < keycount_cache; x++)
+         for (x = 0; x < keyCountCache; x++)
          {
             if (tbl->put(tbl, tmplist[x], "0", 1) == true)
             {
                if (tmplist[x] != NULL)
+               {
                   free(tmplist[x]);
+               }
             }
          }
          free(tmplist);
@@ -1947,7 +2242,9 @@ sint_t getListandSize(KISSDB* db, pstr_t buffer, sint_t size, bool_t bOnlySizeNe
          {
             size_t keyLen = strnlen(kbuf, sizeof(kbuf));
             if (keyLen > 0)
+            {
                tbl->put(tbl, kbuf, "0", 1);
+            }
          }
 
          //count needed size for buffer / copy keys to buffer
@@ -1972,82 +2269,132 @@ sint_t getListandSize(KISSDB* db, pstr_t buffer, sint_t size, bool_t bOnlySizeNe
          free(memory);
       }
       else
+      {
          return PERS_COM_ERR_MALLOC;
+      }
    }
    return result;
 }
 
-
-
-
 int createCache(KISSDB* db)
 {
-   Kdb_bool shmem_creator;
+   Kdb_bool shmCreator;
    int status = -1;
 
-   db->shmem_cached_fd = kdbShmemOpen(db->shmem_cached_name, PERS_CACHE_MEMSIZE, &shmem_creator);
-   if (db->shmem_cached_fd != -1)
+   db->sharedCacheFd = kdbShmemOpen(db->cacheName, PERS_CACHE_MEMSIZE, &shmCreator);
+   if (db->sharedCacheFd != -1)
    {
-      db->shmem_cached = (void*) getKdbShmemPtr(db->shmem_cached_fd, PERS_CACHE_MEMSIZE);
-      if (db->shmem_cached != ((void *) -1))
-      {
-         db->tbl = qhasharr(db->shmem_cached, PERS_CACHE_MEMSIZE);
-         if (db->tbl != NULL)
+      db->sharedCache = (void*) getKdbShmemPtr(db->sharedCacheFd, PERS_CACHE_MEMSIZE);
+      if (db->sharedCache != ((void*) -1))
+      {
+         // for dynamic cache -> create reference into array db->tbl[0] = qhasharr(db->sharedCache, PERS_CACHE_MEMSIZE);
+         /*
+          * Add a function called addCache that resizes shared memory with the size of PERS_CACHE_MEMSIZE
+          * Then init the additional cache -> db->tbl[n] = qhasharr(db->sharedCache + (n * PERS_CACHE_MEMSIZE) , PERS_CACHE_MEMSIZE)
+          * Other processes must recognize additional created caches and reopen them with -> db->tbl[0 - n] = qhasharr(db->sharedCache + (n * PERS_CACHE_MEMSIZE) , 0);
+          * Store the count of created caches in shared information
+          */
+         db->tbl[0] = qhasharr(db->sharedCache, PERS_CACHE_MEMSIZE);
+         if (db->tbl[0] != NULL)
          {
             status = 0;
-            db->shmem_info->cache_initialised = Kdb_true;
+            db->shared->cacheCreated = Kdb_true;
          }
       }
    }
    if (status != 0)
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-            DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Error: Failed to create cache"));
+   {
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__); DLT_STRING(":"); DLT_STRING("Failed to create cache"); DLT_STRING(strerror(errno)));
+   }
    return status;
 }
 
 
-
 int openCache(KISSDB* db)
 {
-   Kdb_bool shmem_creator;
+   Kdb_bool shmCreator;
    int status = -1;
 
    //only open shared memory again if filedescriptor is not initialised yet
-   if (db->shmem_cached_fd <= 0) //not shared filedescriptor
+   if (db->sharedCacheFd <= 0) //not shared filedescriptor
    {
-      db->shmem_cached_fd = kdbShmemOpen(db->shmem_cached_name, PERS_CACHE_MEMSIZE, &shmem_creator);
-      if (db->shmem_cached_fd != -1)
+      db->sharedCacheFd = kdbShmemOpen(db->cacheName, PERS_CACHE_MEMSIZE, &shmCreator);
+      if (db->sharedCacheFd != -1)
       {
-         db->shmem_cached = (void*) getKdbShmemPtr(db->shmem_cached_fd, PERS_CACHE_MEMSIZE);
-         if (db->shmem_cached != ((void *) -1))
+         db->sharedCache = (void*) getKdbShmemPtr(db->sharedCacheFd, PERS_CACHE_MEMSIZE);
+         if (db->sharedCache != ((void*) -1))
          {
             // use existent hash-table
-            db->tbl = qhasharr(db->shmem_cached, 0);
-            if (db->tbl != NULL)
+            db->tbl[0] = qhasharr(db->sharedCache, 0);
+            if (db->tbl[0] != NULL)
+            {
                status = 0;
+            }
          }
       }
    }
    else
+   {
       status = 0;
+   }
    if (status != 0)
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-            DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Error: Failed to open cache"));
+   {
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__), DLT_STRING(":"), DLT_STRING("Failed to open cache"));
+   }
    return status;
 }
 
 
+#if 0
+int addCache(KISSDB* db)
+{
+   //ftruncate db->sharedCacheFd (oldsize + additionalspace)
+
+   //printf("start ftruncate new cache db->tbl[0]->data->maxslots = %d\n", db->tbl[0]->data->maxslots);
+   if( ftruncate(db->sharedCacheFd, db->shared->cacheSize + PERS_CACHE_MEMSIZE) < 0)
+   {
+      printf("Cache resize failed: %s \n", strerror(errno));
+   }
+   //printf("end  ftruncate new cache db->tbl[0]->data->maxslots = %d\n", db->tbl[0]->data->maxslots);
+
+   //mremap oldsize , newsize
+   //store new cache pointer for this process in db->sharedCache
+   db->sharedCache = mremap(db->sharedCache, db->shared->cacheSize , db->shared->cacheSize + PERS_CACHE_MEMSIZE, MREMAP_MAYMOVE );
+   if (db->sharedCache == MAP_FAILED)
+   {
+      printf("cacheresize MAP_FAILED \n");
+   }
+   //printf("end  mremap new cache db->tbl[0]->data->maxslots = %d\n", db->tbl[0]->data->maxslots);
+   //printf("adding cache into db->tbl[%d],----- ptr: %p \n",db->shared->cacheCount, db->sharedCache + (db->shared->cacheCount * PERS_CACHE_MEMSIZE));
+
+   db->tbl[db->shared->cacheCount] = qhasharr(db->sharedCache + (db->shared->cacheCount * PERS_CACHE_MEMSIZE) , PERS_CACHE_MEMSIZE);
+   db->cacheReferenced++;
+   //printf("here 1 \n ");
+
+   //printf("end  qhasharr new cache db->tbl[0]->data->maxslots = %d\n", db->tbl[0]->data->maxslots);
+
+   //store new size in shared memory
+   db->shared->cacheSize += PERS_CACHE_MEMSIZE;
+   db->shared->cacheCount++;
+   // add check if cache was resized (check local mapped size versus shared mapped size) for all processes when cache is accessed and do a remap for new size without truncation
+   return 0;
+}
+#endif
+
+
 int closeCache(KISSDB* db)
 {
    int status = -1;
-   if (kdbShmemClose(db->shmem_cached_fd, db->shmem_cached_name) != Kdb_false)
+   if (kdbShmemClose(db->sharedCacheFd, db->cacheName) != Kdb_false)
    {
-      free(db->shmem_cached_name); //free memory for name  obtained by kdbGetShmName() function
-      if (freeKdbShmemPtr(db->shmem_cached, PERS_CACHE_MEMSIZE) != Kdb_false)
+      if (freeKdbShmemPtr(db->sharedCache, PERS_CACHE_MEMSIZE) != Kdb_false)
+      {
          status = 0;
+      }
    }
    if (status != 0)
-      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR,
-            DLT_STRING(__FUNCTION__); DLT_STRING(":");DLT_STRING("Error: Failed to close cache"));
+   {
+      DLT_LOG(persComLldbDLTCtx, DLT_LOG_ERROR, DLT_STRING(__FUNCTION__), DLT_STRING(":"), DLT_STRING("Failed to close cache"));
+   }
    return status;
 }
diff --git a/src/pers_local_shared_db_access.c b/src/pers_local_shared_db_access.c
index a74f82c..638a2f4 100644
--- a/src/pers_local_shared_db_access.c
+++ b/src/pers_local_shared_db_access.c
@@ -1,8 +1,10 @@
 /**********************************************************************************************************************
 *
 * Copyright (C) 2012 Continental Automotive Systems, Inc.
+* Copyright (C) 2014 XS Embedded GmbH
 *
 * Author: Ionut.Ieremie@continental-corporation.com
+*         simon.disch@xse.de
 *
 * Implementation of persComDbAccess.h
 *
@@ -28,6 +30,16 @@
 #include "persComErrors.h"
 
 /**
+* \brief returns the max DB key data size
+*
+* \return the size
+*/
+int persComDbgetMaxKeyValueSize(void)
+{
+   return PERS_DB_MAX_SIZE_KEY_DATA;
+}
+
+/**
  * \brief Obtain a handler to DB indicated by dbPathname
  * \note : DB is created if it does not exist and (bForceCreationIfNotPresent != 0)
  *