index/mbox/mbox-lock.c

	mbox-lock.c revision cfddb734b85ceaf49451d2f68aaad64a860ca6f6
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski/* Copyright (C) 2002 Timo Sirainen */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include "lib.h"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include "mail-index-private.h"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include "mbox-storage.h"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include "mbox-file.h"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include "mbox-lock.h"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include <time.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include <stdlib.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include <unistd.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include <fcntl.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#include <sys/stat.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#ifdef HAVE_FLOCK
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#  include <sys/file.h>
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#endif
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski/* 0.1 .. 0.2msec */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#define LOCK_RANDOM_USLEEP_TIME (100000 + (unsigned int)rand() % 100000)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski/* lock methods to use in wanted order */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#define DEFAULT_READ_LOCK_METHODS "fcntl"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#define DEFAULT_WRITE_LOCK_METHODS "dotlock fcntl"
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski/* lock timeout */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#define DEFAULT_LOCK_TIMEOUT (5*60)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski/* assume stale dotlock if mbox file hasn't changed for n seconds */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#define DEFAULT_DOTLOCK_CHANGE_TIMEOUT (120)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskienum mbox_lock_type {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    MBOX_LOCK_DOTLOCK,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    MBOX_LOCK_FCNTL,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    MBOX_LOCK_FLOCK,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    MBOX_LOCK_LOCKF,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    MBOX_LOCK_COUNT
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski};
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistruct mbox_lock_context {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    struct mbox_mailbox *mbox;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    int lock_status[MBOX_LOCK_COUNT];
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    bool checked_file;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    int lock_type;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    bool dotlock_last_stale;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski};
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistruct mbox_lock_data {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    enum mbox_lock_type type;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    const char *name;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    int (*func)(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            time_t max_wait_time);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski};
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_lock_dotlock(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                 time_t max_wait_time);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_lock_fcntl(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski               time_t max_wait_time);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#ifdef HAVE_FLOCK
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_lock_flock(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski               time_t max_wait_time);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#else
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#  define mbox_lock_flock NULL
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#endif
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#ifdef HAVE_LOCKF
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_lock_lockf(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski               time_t max_wait_time);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#else
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#  define mbox_lock_lockf NULL
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski#endif
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistruct mbox_lock_data lock_data[] = {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    { MBOX_LOCK_DOTLOCK, "dotlock", mbox_lock_dotlock },
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    { MBOX_LOCK_FCNTL, "fcntl", mbox_lock_fcntl },
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    { MBOX_LOCK_FLOCK, "flock", mbox_lock_flock },
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    { MBOX_LOCK_LOCKF, "lockf", mbox_lock_lockf },
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    { 0, NULL, NULL }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski};
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic bool lock_settings_initialized = FALSE;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic enum mbox_lock_type read_locks[MBOX_LOCK_COUNT+1];
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic enum mbox_lock_type write_locks[MBOX_LOCK_COUNT+1];
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int lock_timeout, dotlock_change_timeout;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_lock_list(struct mbox_lock_context *ctx, int lock_type,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski              time_t max_wait_time, int idx);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic int mbox_unlock_files(struct mbox_lock_context *ctx);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic void mbox_read_lock_methods(const char *str, const char *env,
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                   enum mbox_lock_type *locks)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski{
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        enum mbox_lock_type type;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    const char *const *lock;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    int i, dest;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    for (lock = t_strsplit(str, " "), dest = 0; *lock != NULL; lock++) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        for (type = 0; lock_data[type].name != NULL; type++) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            if (strcasecmp(*lock, lock_data[type].name) == 0) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                type = lock_data[type].type;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                break;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        if (lock_data[type].name == NULL)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            i_fatal("%s: Invalid value %s", env, *lock);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        if (lock_data[type].func == NULL) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            i_fatal("%s: Support for lock type %s "
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                "not compiled into binary", env, *lock);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        for (i = 0; i < dest; i++) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            if (locks[i] == type)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski                i_fatal("%s: Duplicated value %s", env, *lock);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        /* @UNSAFE */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        locks[dest++] = type;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    locks[dest] = (enum mbox_lock_type)-1;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski}
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowskistatic void mbox_init_lock_settings(void)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski{
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    const char *str;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    int r, w;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    str = getenv("MBOX_READ_LOCKS");
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    if (str == NULL) str = DEFAULT_READ_LOCK_METHODS;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    mbox_read_lock_methods(str, "MBOX_READ_LOCKS", read_locks);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    str = getenv("MBOX_WRITE_LOCKS");
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    if (str == NULL) str = DEFAULT_WRITE_LOCK_METHODS;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    mbox_read_lock_methods(str, "MBOX_WRITE_LOCKS", write_locks);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    /* check that read/write list orders match. write_locks must contain
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski       at least read_locks and possibly more. */
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    for (r = w = 0; write_locks[w] != (enum mbox_lock_type)-1; w++) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        if (read_locks[r] == (enum mbox_lock_type)-1)
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            break;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        if (read_locks[r] == write_locks[w])
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            r++;
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    if (read_locks[r] != (enum mbox_lock_type)-1) {
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski        i_fatal("mbox read/write lock list settings are invalid. "
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            "Lock ordering must be the same with both, "
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            "and write locks must contain all read locks "
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski            "(and possibly more)");
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    }
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    str = getenv("MBOX_LOCK_TIMEOUT");
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski    lock_timeout = str == NULL ? DEFAULT_LOCK_TIMEOUT : atoi(str);
cbc7f7ea90538f481b528959e9b6cf837b0dd785Till Mossakowski
    str = getenv("MBOX_DOTLOCK_CHANGE_TIMEOUT");
    dotlock_change_timeout = str == NULL ?
        DEFAULT_DOTLOCK_CHANGE_TIMEOUT : atoi(str);

        lock_settings_initialized = TRUE;
}

static int mbox_file_open_latest(struct mbox_lock_context *ctx, int lock_type)
{
    struct mbox_mailbox *mbox = ctx->mbox;
    struct stat st;

    if (ctx->checked_file || lock_type == F_UNLCK)
        return 0;

    if (mbox->mbox_fd != -1) {
        if (stat(mbox->path, &st) < 0) {
            mbox_set_syscall_error(mbox, "stat()");
            return -1;
        }

        if (st.st_ino != mbox->mbox_ino ||
            !CMP_DEV_T(st.st_dev, mbox->mbox_dev))
            mbox_file_close(mbox);
    }

    if (mbox->mbox_fd == -1) {
        if (mbox_file_open(mbox) < 0)
            return -1;
    }

    ctx->checked_file = TRUE;
    return 0;
}

static bool dotlock_callback(unsigned int secs_left, bool stale, void *context)
{
        struct mbox_lock_context *ctx = context;
    enum mbox_lock_type *lock_types;
    int i;

    if (stale && !ctx->dotlock_last_stale) {
        /* get next index we wish to try locking. it's the one after
           dotlocking. */
        lock_types = ctx->lock_type == F_WRLCK ||
            (ctx->lock_type == F_UNLCK &&
             ctx->mbox->mbox_lock_type == F_WRLCK) ?
            write_locks : read_locks;

        for (i = 0; lock_types[i] != (enum mbox_lock_type)-1; i++) {
            if (lock_types[i] == MBOX_LOCK_DOTLOCK)
                break;
        }

        if (lock_types[i] != (enum mbox_lock_type)-1 &&
            lock_types[i+1] != (enum mbox_lock_type)-1) {
            i++;
            if (mbox_lock_list(ctx, ctx->lock_type, 0, i) <= 0) {
                /* we couldn't get fd lock -
                   it's really locked */
                ctx->dotlock_last_stale = TRUE;
                return FALSE;
            }
            (void)mbox_lock_list(ctx, F_UNLCK, 0, i);
        }
    }
    ctx->dotlock_last_stale = stale;

    index_storage_lock_notify(&ctx->mbox->ibox, stale ?
                  MAILBOX_LOCK_NOTIFY_MAILBOX_OVERRIDE :
                  MAILBOX_LOCK_NOTIFY_MAILBOX_ABORT,
                  secs_left);
    return TRUE;
}

static int mbox_lock_dotlock(struct mbox_lock_context *ctx, int lock_type,
                 time_t max_wait_time __attr_unused__)
{
    struct mbox_mailbox *mbox = ctx->mbox;
    struct dotlock_settings set;
    int ret;

    if (lock_type == F_UNLCK) {
        if (!mbox->mbox_dotlocked)
            return 1;

        if (file_dotlock_delete(&mbox->mbox_dotlock) <= 0) {
            mbox_set_syscall_error(mbox, "file_dotlock_delete()");
            ret = -1;
        }
                mbox->mbox_dotlocked = FALSE;
        return 1;
    }

    if (mbox->mbox_dotlocked)
        return 1;

        ctx->dotlock_last_stale = -1;

    memset(&set, 0, sizeof(set));
    set.timeout = lock_timeout;
    set.stale_timeout = dotlock_change_timeout;
    set.callback = dotlock_callback;
    set.context = ctx;

    ret = file_dotlock_create(&set, mbox->path, 0, &mbox->mbox_dotlock);
    if (ret < 0) {
        mbox_set_syscall_error(mbox, "file_lock_dotlock()");
        return -1;
    }
    if (ret == 0) {
        mail_storage_set_error(STORAGE(mbox->storage),
                       "Timeout while waiting for lock");
        return 0;
    }
    mbox->mbox_dotlocked = TRUE;

    if (mbox_file_open_latest(ctx, lock_type) < 0)
        return -1;
    return 1;
}

#ifdef HAVE_FLOCK
static int mbox_lock_flock(struct mbox_lock_context *ctx, int lock_type,
               time_t max_wait_time)
{
    time_t now, last_notify;

    if (mbox_file_open_latest(ctx, lock_type) < 0)
        return -1;

    if (lock_type == F_UNLCK && ctx->mbox->mbox_fd == -1)
        return 1;

    if (lock_type == F_WRLCK)
        lock_type = LOCK_EX;
    else if (lock_type == F_RDLCK)
        lock_type = LOCK_SH;
    else
        lock_type = LOCK_UN;

        last_notify = 0;
    while (flock(ctx->mbox->mbox_fd, lock_type | LOCK_NB) < 0) {
        if (errno != EWOULDBLOCK) {
            mbox_set_syscall_error(ctx->mbox, "flock()");
            return -1;
        }

        now = time(NULL);
        if (now >= max_wait_time)
            return 0;

        if (now != last_notify) {
            index_storage_lock_notify(&ctx->mbox->ibox,
                MAILBOX_LOCK_NOTIFY_MAILBOX_ABORT,
                max_wait_time - now);
        }

        usleep(LOCK_RANDOM_USLEEP_TIME);
    }

    return 1;
}
#endif

#ifdef HAVE_LOCKF
static int mbox_lock_lockf(struct mbox_lock_context *ctx, int lock_type,
               time_t max_wait_time)
{
    time_t now, last_notify;

    if (mbox_file_open_latest(ctx, lock_type) < 0)
        return -1;

    if (lock_type == F_UNLCK && ctx->mbox->mbox_fd == -1)
        return 1;

    if (lock_type != F_UNLCK)
        lock_type = F_TLOCK;
    else
        lock_type = F_ULOCK;

        last_notify = 0;
    while (lockf(ctx->mbox->mbox_fd, lock_type, 0) < 0) {
        if (errno != EAGAIN) {
            mbox_set_syscall_error(ctx->mbox, "lockf()");
            return -1;
        }

        now = time(NULL);
        if (now >= max_wait_time)
            return 0;

        if (now != last_notify) {
            index_storage_lock_notify(&ctx->mbox->ibox,
                MAILBOX_LOCK_NOTIFY_MAILBOX_ABORT,
                max_wait_time - now);
        }

        usleep(LOCK_RANDOM_USLEEP_TIME);
    }

    return 1;
}
#endif

static int mbox_lock_fcntl(struct mbox_lock_context *ctx, int lock_type,
               time_t max_wait_time)
{
    struct flock fl;
    time_t now;
    unsigned int next_alarm;
    int wait_type;

    if (mbox_file_open_latest(ctx, lock_type) < 0)
        return -1;

    if (lock_type == F_UNLCK && ctx->mbox->mbox_fd == -1)
        return 1;

    memset(&fl, 0, sizeof(fl));
    fl.l_type = lock_type;
    fl.l_whence = SEEK_SET;
    fl.l_start = 0;
    fl.l_len = 0;

    if (max_wait_time == 0) {
        /* usually we're waiting here, but if we came from
           mbox_lock_dotlock(), we just want to try locking */
        wait_type = F_SETLK;
    } else {
        wait_type = F_SETLKW;
        now = time(NULL);
        if (now >= max_wait_time)
            alarm(1);
        else
            alarm(I_MIN(max_wait_time - now, 5));
    }

    while (fcntl(ctx->mbox->mbox_fd, wait_type, &fl) < 0) {
        if (errno != EINTR) {
            mbox_set_syscall_error(ctx->mbox, "fcntl()");
            alarm(0);
            return -1;
        }

        now = time(NULL);
        if (now >= max_wait_time) {
            alarm(0);
            return 0;
        }

        /* notify locks once every 5 seconds.
           try to use rounded values. */
        next_alarm = (max_wait_time - now) % 5;
        if (next_alarm == 0)
            next_alarm = 5;
        alarm(next_alarm);

        index_storage_lock_notify(&ctx->mbox->ibox,
                      MAILBOX_LOCK_NOTIFY_MAILBOX_ABORT,
                      max_wait_time - now);
    }

    alarm(0);
    return 1;
}

static int mbox_lock_list(struct mbox_lock_context *ctx, int lock_type,
              time_t max_wait_time, int idx)
{
    enum mbox_lock_type *lock_types;
        enum mbox_lock_type type;
    int i, ret = 0, lock_status;

    ctx->lock_type = lock_type;

    lock_types = lock_type == F_WRLCK ||
        (lock_type == F_UNLCK && ctx->mbox->mbox_lock_type == F_WRLCK) ?
        write_locks : read_locks;
    for (i = idx; lock_types[i] != (enum mbox_lock_type)-1; i++) {
        type = lock_types[i];
        lock_status = lock_type != F_UNLCK;

        if (ctx->lock_status[type] == lock_status)
            continue;
        ctx->lock_status[type] = lock_status;

        ret = lock_data[type].func(ctx, lock_type, max_wait_time);
        if (ret <= 0)
            break;
    }
    return ret;
}

static int mbox_update_locking(struct mbox_mailbox *mbox, int lock_type)
{
    struct mbox_lock_context ctx;
    time_t max_wait_time;
    int ret, i;
    bool drop_locks;

        index_storage_lock_notify_reset(&mbox->ibox);

    if (!lock_settings_initialized)
                mbox_init_lock_settings();

    if (mbox->mbox_fd == -1 && mbox->mbox_file_stream != NULL) {
        /* read-only mbox stream. no need to lock. */
        i_assert(mbox->mbox_readonly);
        mbox->mbox_lock_type = lock_type;
        return 1;
    }

    max_wait_time = time(NULL) + lock_timeout;

    memset(&ctx, 0, sizeof(ctx));
    ctx.mbox = mbox;

    if (mbox->mbox_lock_type == F_WRLCK) {
        /* dropping to shared lock. first drop those that we
           don't remove completely. */
        for (i = 0; i < MBOX_LOCK_COUNT; i++)
            ctx.lock_status[i] = 1;
        for (i = 0; read_locks[i] != (enum mbox_lock_type)-1; i++)
            ctx.lock_status[read_locks[i]] = 0;
        drop_locks = TRUE;
    } else {
        drop_locks = FALSE;
    }

    mbox->mbox_lock_type = lock_type;
    ret = mbox_lock_list(&ctx, lock_type, max_wait_time, 0);
    if (ret <= 0) {
        if (!drop_locks)
            (void)mbox_unlock_files(&ctx);
        if (ret == 0) {
            mail_storage_set_error(STORAGE(mbox->storage),
                "Timeout while waiting for lock");
        }
        return ret;
    }

    if (drop_locks) {
        /* dropping to shared lock: drop the locks that are only
           in write list */
        memset(ctx.lock_status, 0, sizeof(ctx.lock_status));
        for (i = 0; write_locks[i] != (enum mbox_lock_type)-1; i++)
            ctx.lock_status[write_locks[i]] = 1;
        for (i = 0; read_locks[i] != (enum mbox_lock_type)-1; i++)
            ctx.lock_status[read_locks[i]] = 0;

        mbox->mbox_lock_type = F_WRLCK;
        (void)mbox_lock_list(&ctx, F_UNLCK, 0, 0);
        mbox->mbox_lock_type = F_RDLCK;
    }

    return 1;
}

int mbox_lock(struct mbox_mailbox *mbox, int lock_type,
          unsigned int *lock_id_r)
{
    int ret;

    /* allow only unlock -> shared/exclusive or exclusive -> shared */
    i_assert(lock_type == F_RDLCK || lock_type == F_WRLCK);
    i_assert(lock_type == F_RDLCK || mbox->mbox_lock_type != F_RDLCK);

    /* mbox must be locked before index */
    i_assert(mbox->ibox.index->lock_type != F_WRLCK);

    if (mbox->mbox_lock_type == F_UNLCK) {
        ret = mbox_update_locking(mbox, lock_type);
        if (ret <= 0)
            return ret;

        mbox->mbox_lock_id += 2;
    }

    if (lock_type == F_RDLCK) {
        mbox->mbox_shared_locks++;
        *lock_id_r = mbox->mbox_lock_id;
    } else {
        mbox->mbox_excl_locks++;
        *lock_id_r = mbox->mbox_lock_id + 1;
    }
    return 1;
}

static int mbox_unlock_files(struct mbox_lock_context *ctx)
{
    int ret = 0;

    if (mbox_lock_list(ctx, F_UNLCK, 0, 0) < 0)
        ret = -1;

    if (ctx->mbox->ibox.mail_read_mmaped) {
        /* make sure we don't keep mmap() between locks */
        mbox_file_close_stream(ctx->mbox);
    }

    ctx->mbox->mbox_lock_id += 2;
    ctx->mbox->mbox_lock_type = F_UNLCK;
    return ret;
}

int mbox_unlock(struct mbox_mailbox *mbox, unsigned int lock_id)
{
    struct mbox_lock_context ctx;
    int i;

    i_assert(mbox->mbox_lock_id == (lock_id & ~1));

    if (lock_id & 1) {
        /* dropping exclusive lock */
        i_assert(mbox->mbox_excl_locks > 0);
        if (--mbox->mbox_excl_locks > 0)
            return 0;
        if (mbox->mbox_shared_locks > 0) {
            /* drop to shared lock */
            if (mbox_update_locking(mbox, F_RDLCK) < 0)
                return -1;
            return 0;
        }
    } else {
        /* dropping shared lock */
        i_assert(mbox->mbox_shared_locks > 0);
        if (--mbox->mbox_shared_locks > 0)
            return 0;
        if (mbox->mbox_excl_locks > 0)
            return 0;
    }
    /* all locks gone */

    memset(&ctx, 0, sizeof(ctx));
    ctx.mbox = mbox;

    for (i = 0; i < MBOX_LOCK_COUNT; i++)
        ctx.lock_status[i] = 1;

    return mbox_unlock_files(&ctx);
}