lmdb.c

Go to the documentation of this file.

 
#include "config.h"
#include <lmdb.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "lib.h"

#if (UINTPTR_MAX == 0xffffffff)
static const size_t LMDB_DB_SIZE = 2147483648;
#elif (UINTPTR_MAX == 0xffffffffffffffff)
static const size_t LMDB_DB_SIZE = 107374182400;
#else
#error
#endif

enum LmdbTxnMode
{
  TXN_UNINITIALIZED, 
  TXN_READ,          
  TXN_WRITE,         
};

struct LmdbStoreData
{
  MDB_env *env;              
  MDB_txn *txn;              
  MDB_dbi db;                
  enum LmdbTxnMode txn_mode; 
};

static void lmdb_sdata_free(struct LmdbStoreData **ptr)
{
  FREE(ptr);
}

static struct LmdbStoreData *lmdb_sdata_new(void)
{
  return MUTT_MEM_CALLOC(1, struct LmdbStoreData);
}

static int lmdb_get_read_txn(struct LmdbStoreData *sdata)
{
  int rc;
 
  if (sdata->txn && ((sdata->txn_mode == TXN_READ) || (sdata->txn_mode == TXN_WRITE)))
    return MDB_SUCCESS;
 
  if (sdata->txn)
    rc = mdb_txn_renew(sdata->txn);
  else
    rc = mdb_txn_begin(sdata->env, NULL, MDB_RDONLY, &sdata->txn);
 
  if (rc == MDB_SUCCESS)
  {
    sdata->txn_mode = TXN_READ;
  }
  else
  {
    mutt_debug(LL_DEBUG2, "%s: %s\n",
               sdata->txn ? "mdb_txn_renew" : "mdb_txn_begin", mdb_strerror(rc));
  }
 
  return rc;
}

static int lmdb_get_write_txn(struct LmdbStoreData *sdata)
{
  if (sdata->txn)
  {
    if (sdata->txn_mode == TXN_WRITE)
      return MDB_SUCCESS;
 
    /* Free up the memory for readonly or reset transactions */
    mdb_txn_abort(sdata->txn);
  }
 
  int rc = mdb_txn_begin(sdata->env, NULL, 0, &sdata->txn);
  if (rc == MDB_SUCCESS)
    sdata->txn_mode = TXN_WRITE;
  else
    mutt_debug(LL_DEBUG2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
 
  return rc;
}

static StoreHandle *store_lmdb_open(const char *path, bool create)
{
  if (!path)
    return NULL;
 
  if (!create && access(path, F_OK) != 0)
  {
    return NULL;
  }
 
  struct LmdbStoreData *sdata = lmdb_sdata_new();
 
  int rc = mdb_env_create(&sdata->env);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_env_create: %s\n", mdb_strerror(rc));
    lmdb_sdata_free(&sdata);
    return NULL;
  }
 
  mdb_env_set_mapsize(sdata->env, LMDB_DB_SIZE);
 
  rc = mdb_env_open(sdata->env, path, MDB_NOSUBDIR, 0600);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_env_open: %s\n", mdb_strerror(rc));
    goto fail_env;
  }
 
  rc = lmdb_get_read_txn(sdata);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_txn_begin: %s\n", mdb_strerror(rc));
    goto fail_env;
  }
 
  rc = mdb_dbi_open(sdata->txn, NULL, MDB_CREATE, &sdata->db);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_dbi_open: %s\n", mdb_strerror(rc));
    goto fail_dbi;
  }
 
  mdb_txn_reset(sdata->txn);
  sdata->txn_mode = TXN_UNINITIALIZED;
  // Return an opaque pointer
  return (StoreHandle *) sdata;
 
fail_dbi:
  mdb_txn_abort(sdata->txn);
  sdata->txn_mode = TXN_UNINITIALIZED;
  sdata->txn = NULL;
 
fail_env:
  mdb_env_close(sdata->env);
  lmdb_sdata_free(&sdata);
  return NULL;
}

static void *store_lmdb_fetch(StoreHandle *store, const char *key, size_t klen, size_t *vlen)
{
  if (!store)
    return NULL;
 
  *vlen = 0;
 
  MDB_val dkey = { 0 };
  MDB_val data = { 0 };
 
  // Decloak an opaque pointer
  struct LmdbStoreData *sdata = store;
 
  dkey.mv_data = (void *) key;
  dkey.mv_size = klen;
  data.mv_data = NULL;
  data.mv_size = 0;
  int rc = lmdb_get_read_txn(sdata);
  if (rc != MDB_SUCCESS)
  {
    sdata->txn = NULL;
    mutt_debug(LL_DEBUG2, "txn_renew: %s\n", mdb_strerror(rc));
    return NULL;
  }
  rc = mdb_get(sdata->txn, sdata->db, &dkey, &data);
  if (rc == MDB_NOTFOUND)
  {
    return NULL;
  }
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_get: %s\n", mdb_strerror(rc));
    return NULL;
  }
 
  *vlen = data.mv_size;
  return data.mv_data;
}

static void store_lmdb_free(StoreHandle *store, void **ptr)
{
  /* LMDB data is owned by the database */
}

static int store_lmdb_store(StoreHandle *store, const char *key, size_t klen,
                            void *value, size_t vlen)
{
  if (!store)
    return -1;
 
  MDB_val dkey = { 0 };
  MDB_val databuf = { 0 };
 
  // Decloak an opaque pointer
  struct LmdbStoreData *sdata = store;
 
  dkey.mv_data = (void *) key;
  dkey.mv_size = klen;
  databuf.mv_data = value;
  databuf.mv_size = vlen;
  int rc = lmdb_get_write_txn(sdata);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "lmdb_get_write_txn: %s\n", mdb_strerror(rc));
    return rc;
  }
  rc = mdb_put(sdata->txn, sdata->db, &dkey, &databuf, 0);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "mdb_put: %s\n", mdb_strerror(rc));
    mdb_txn_abort(sdata->txn);
    sdata->txn_mode = TXN_UNINITIALIZED;
    sdata->txn = NULL;
  }
  return rc;
}

static int store_lmdb_delete_record(StoreHandle *store, const char *key, size_t klen)
{
  if (!store)
    return -1;
 
  MDB_val dkey = { 0 };
 
  // Decloak an opaque pointer
  struct LmdbStoreData *sdata = store;
 
  dkey.mv_data = (void *) key;
  dkey.mv_size = klen;
  int rc = lmdb_get_write_txn(sdata);
  if (rc != MDB_SUCCESS)
  {
    mutt_debug(LL_DEBUG2, "lmdb_get_write_txn: %s\n", mdb_strerror(rc));
    return rc;
  }
  rc = mdb_del(sdata->txn, sdata->db, &dkey, NULL);
  if ((rc != MDB_SUCCESS) && (rc != MDB_NOTFOUND))
  {
    mutt_debug(LL_DEBUG2, "mdb_del: %s\n", mdb_strerror(rc));
    mdb_txn_abort(sdata->txn);
    sdata->txn_mode = TXN_UNINITIALIZED;
    sdata->txn = NULL;
  }
 
  return rc;
}

static void store_lmdb_close(StoreHandle **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  // Decloak an opaque pointer
  struct LmdbStoreData *sdata = *ptr;
 
  if (sdata->txn)
  {
    if (sdata->txn_mode == TXN_WRITE)
      mdb_txn_commit(sdata->txn);
    else
      mdb_txn_abort(sdata->txn);
 
    sdata->txn_mode = TXN_UNINITIALIZED;
    sdata->txn = NULL;
  }
 
  mdb_env_close(sdata->env);
  lmdb_sdata_free((struct LmdbStoreData **) ptr);
}

static const char *store_lmdb_version(void)
{
  return "lmdb " MDB_VERSION_STRING;
}
 
STORE_BACKEND_OPS(lmdb)