/* Copyright (c) Dovecot authors, see top-level COPYING file */

#include "lib.h"

#include "ioloop.h"

#include "module-context.h"

#include "eacces-error.h"

#include "mail-index-private.h"

#include "mail-index-alloc-cache.h"

#define MAIL_INDEX_ALLOC_CACHE_CONTEXT(obj) \

  MODULE_CONTEXT(obj, mail_index_alloc_cache_index_module)

/* How many seconds to keep index opened for reuse after it's been closed */

#define INDEX_CACHE_TIMEOUT 10

/* How many closed indexes to keep */

#define INDEX_CACHE_MAX 3

struct mail_index_alloc_cache_list {

  union mail_index_module_context module_ctx;

  struct mail_index_alloc_cache_list *next;

  struct mail_index *index;

  char *mailbox_path;

  int refcount;

  bool referenced;

  dev_t index_dir_dev;

  ino_t index_dir_ino;

  time_t destroy_time;

};

static MODULE_CONTEXT_DEFINE_INIT(mail_index_alloc_cache_index_module,

          &mail_index_module_register);

static struct mail_index_alloc_cache_list *indexes = NULL;

static unsigned int indexes_cache_references_count = 0;

static struct timeout *to_index = NULL;

static struct mail_index_alloc_cache_list *

mail_index_alloc_cache_add(struct mail_index *index,

         const char *mailbox_path, struct stat *st)

{

  struct mail_index_alloc_cache_list *list;

  list = i_new(struct mail_index_alloc_cache_list, 1);

  list->refcount = 1;

  list->index = index;

  list->mailbox_path = i_strdup(mailbox_path);

  list->index_dir_dev = st->st_dev;

  list->index_dir_ino = st->st_ino;

  list->next = indexes;

  indexes = list;

  MODULE_CONTEXT_SET(index, mail_index_alloc_cache_index_module, list);

  return list;

}

static void

mail_index_alloc_cache_list_unref(struct mail_index_alloc_cache_list *list)

{

  i_assert(list->referenced);

  i_assert(indexes_cache_references_count > 0);

  indexes_cache_references_count--;

  mail_index_close(list->index);

  list->referenced = FALSE;

}

static void

mail_index_alloc_cache_list_free(struct mail_index_alloc_cache_list *list)

{

  i_assert(list->refcount == 0);

  if (list->referenced)

    mail_index_alloc_cache_list_unref(list);

  mail_index_free(&list->index);

  i_free(list->mailbox_path);

  i_free(list);

}

static struct mail_index_alloc_cache_list *

mail_index_alloc_cache_find_and_expire(const char *mailbox_path,

               const char *index_dir,

               const struct stat *index_st)

{

  struct mail_index_alloc_cache_list **indexp, *rec, *match;

  unsigned int destroy_count;

  struct stat st;

  destroy_count = 0; match = NULL;

  for (indexp = &indexes; *indexp != NULL;) {

    rec = *indexp;

    if (match != NULL) {

      /* already found the index. we're just going through

         the rest of them to drop 0 refcounts */

    } else if (rec->refcount == 0 && rec->index->open_count == 0) {

      /* index is already closed. don't even try to

         reuse it. */

    } else if (index_dir != NULL && rec->index_dir_ino != 0) {

      if (index_st->st_ino == rec->index_dir_ino &&

          CMP_DEV_T(index_st->st_dev, rec->index_dir_dev)) {

        /* make sure the directory still exists.

           it might have been renamed and we're trying

           to access it via its new path now. */

        if (stat(rec->index->dir, &st) < 0 ||

            st.st_ino != index_st->st_ino ||

            !CMP_DEV_T(st.st_dev, index_st->st_dev))

          rec->destroy_time = 0;

        else

          match = rec;

      }

    } else if (mailbox_path != NULL && rec->mailbox_path != NULL &&

         index_dir == NULL && rec->index_dir_ino == 0) {

      if (strcmp(mailbox_path, rec->mailbox_path) == 0)

        match = rec;

    }

    if (rec->refcount == 0 && rec != match) {

      if (rec->destroy_time <= ioloop_time ||

          destroy_count >= INDEX_CACHE_MAX) {

        *indexp = rec->next;

        mail_index_alloc_cache_list_free(rec);

        continue;

      } else {

        destroy_count++;

      }

    }

                indexp = &(*indexp)->next;

  }

  return match;

}

struct mail_index *

mail_index_alloc_cache_get(struct event *parent_event, const char *mailbox_path,

         const char *index_dir, const char *prefix)

{

  struct mail_index_alloc_cache_list *match;

  struct stat st;

  /* compare index_dir inodes so we don't break even with symlinks.

     if index_dir doesn't exist yet or if using in-memory indexes, just

     compare mailbox paths */

  i_zero(&st);

  if (index_dir == NULL) {

    /* in-memory indexes */

  } else if (stat(index_dir, &st) < 0) {

    if (errno == ENOENT) {

      /* it'll be created later */

    } else if (ENOACCESS(errno)) {

      e_error(parent_event, "%s",

        eacces_error_get("stat", index_dir));

    } else {

      e_error(parent_event, "stat(%s) failed: %m", index_dir);

    }

  }

  match = mail_index_alloc_cache_find_and_expire(mailbox_path,

                   index_dir, &st);

  if (match == NULL) {

    struct mail_index *index =

      mail_index_alloc(parent_event, index_dir, prefix);

    match = mail_index_alloc_cache_add(index, mailbox_path, &st);

  } else {

    match->refcount++;

  }

  i_assert(match->index != NULL);

  return match->index;

}

struct mail_index *

mail_index_alloc_cache_find(const char *index_dir)

{

  struct mail_index_alloc_cache_list *rec;

  struct stat st;

  if (stat(index_dir, &st) < 0) {

    if (errno != ENOENT)

      i_error("stat(%s) failed: %m", index_dir);

    return NULL;

  }

  for (rec = indexes; rec != NULL; rec = rec->next) {

    if (st.st_ino == rec->index_dir_ino &&

        CMP_DEV_T(st.st_dev, rec->index_dir_dev))

      return rec->index;

  }

  return NULL;

}

static bool destroy_unrefed(unsigned int min_destroy_count)

{

  struct mail_index_alloc_cache_list **list, *rec;

  bool destroyed = FALSE;

  bool seen_ref0 = FALSE;

  for (list = &indexes; *list != NULL;) {

    rec = *list;

    if (rec->refcount == 0 &&

        (min_destroy_count > 0 || rec->destroy_time <= ioloop_time)) {

      *list = rec->next;

      destroyed = TRUE;

      mail_index_alloc_cache_list_free(rec);

      if (min_destroy_count > 0)

        min_destroy_count--;

    } else {

      if (rec->refcount == 0)

        seen_ref0 = TRUE;

      if (min_destroy_count > 0 &&

          rec->index->open_count == 1 &&

          rec->referenced) {

        /* we're the only one keeping this index open.

           we might be here, because the caller is

           deleting this mailbox and wants its indexes

           to be closed. so close it. */

        destroyed = TRUE;

        mail_index_alloc_cache_list_unref(rec);

      }

      list = &(*list)->next;

    }

  }

  if (!seen_ref0 && to_index != NULL)

    timeout_remove(&to_index);

  return destroyed;

}

static void ATTR_NULL(1)

index_removal_timeout(void *context ATTR_UNUSED)

{

  destroy_unrefed(0);

}

void mail_index_alloc_cache_unref(struct mail_index **_index)

{

  struct mail_index *index = *_index;

  struct mail_index_alloc_cache_list *list, **listp;

  *_index = NULL;

  list = NULL;

  for (listp = &indexes; *listp != NULL; listp = &(*listp)->next) {

    if ((*listp)->index == index) {

      list = *listp;

      break;

    }

  }

  i_assert(list != NULL);

  i_assert(list->refcount > 0);

  list->refcount--;

  list->destroy_time = ioloop_time + INDEX_CACHE_TIMEOUT;

  if (list->refcount == 0 && index->open_count == 0) {

    /* index was already closed. don't even try to cache it. */

    *listp = list->next;

    mail_index_alloc_cache_list_free(list);

  } else if (to_index == NULL) {

    /* Add to root ioloop in case we got here from an inner

       ioloop which gets destroyed too early. */

    to_index = timeout_add_to(io_loop_get_root(),

            INDEX_CACHE_TIMEOUT*1000/2,

            index_removal_timeout, NULL);

  }

}

void mail_index_alloc_cache_destroy_unrefed(void)

{

  destroy_unrefed(UINT_MAX);

}

void mail_index_alloc_cache_index_opened(struct mail_index *index)

{

  struct mail_index_alloc_cache_list *list =

    MAIL_INDEX_ALLOC_CACHE_CONTEXT(index);

  struct stat st;

  if (list != NULL && list->index_dir_ino == 0 &&

      !MAIL_INDEX_IS_IN_MEMORY(index)) {

    /* newly created index directory. update its stat. */

    if (stat(index->dir, &st) == 0) {

      list->index_dir_ino = st.st_ino;

      list->index_dir_dev = st.st_dev;

    }

  }

}

void mail_index_alloc_cache_index_closing(struct mail_index *index)

{

  struct mail_index_alloc_cache_list *list =

    MAIL_INDEX_ALLOC_CACHE_CONTEXT(index);

  i_assert(index->open_count > 0);

  if (index->open_count > 1 || list == NULL)

    return;

  if (list->referenced) {

    /* we're closing our referenced index */

    return;

  }

  while (indexes_cache_references_count > INDEX_CACHE_MAX) {

    if (!destroy_unrefed(1)) {

      /* our cache is full already, don't keep more */

      return;

    }

  }

  /* keep the index referenced for caching */

  indexes_cache_references_count++;

  list->referenced = TRUE;

  index->open_count++;

}