neovim/src/nvim/memfile.c

/*
 * VIM - Vi IMproved    by Bram Moolenaar
 *
 * Do ":help uganda"  in Vim to read copying and usage conditions.
 * Do ":help credits" in Vim to see a list of people who contributed.
 * See README.txt for an overview of the Vim source code.
 */

/// An abstraction to handle blocks of memory which can be stored in a file.
/// This is the implementation of a sort of virtual memory.
///
/// A memfile consists of a sequence of blocks:
/// - Blocks numbered from 0 upwards have been assigned a place in the actual
///   file. The block number is equal to the page number in the file.
/// - Blocks with negative numbers are currently in memory only. They can be
///   assigned a place in the file when too much memory is being used. At that
///   moment, they get a new, positive, number. A list is used for translation
///   of negative to positive numbers.
///
/// The size of a block is a multiple of a page size, normally the page size of
/// the device the file is on. Most blocks are 1 page long. A block of multiple
/// pages is used for a line that does not fit in a single page.
///
/// Each block can be in memory and/or in a file. The block stays in memory
/// as long as it is locked. If it is no longer locked it can be swapped out to
/// the file. It is only written to the file if it has been changed.
///
/// Under normal operation the file is created when opening the memory file and
/// deleted when closing the memory file. Only with recovery an existing memory
/// file is opened.
///
/// The functions for using a memfile:
///
/// mf_open()         open a new or existing memfile
/// mf_open_file()    open a swap file for an existing memfile
/// mf_close()        close (and delete) a memfile
/// mf_new()          create a new block in a memfile and lock it
/// mf_get()          get an existing block and lock it
/// mf_put()          unlock a block, may be marked for writing
/// mf_free()         remove a block
/// mf_sync()         sync changed parts of memfile to disk
/// mf_release_all()  release as much memory as possible
/// mf_trans_del()    may translate negative to positive block number
/// mf_fullname()     make file name full path (use before first :cd)

#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <string.h>

#include "nvim/vim.h"
#include "nvim/ascii.h"
#include "nvim/memfile.h"
#include "nvim/fileio.h"
#include "nvim/memline.h"
#include "nvim/message.h"
#include "nvim/misc1.h"
#include "nvim/misc2.h"
#include "nvim/memory.h"
#include "nvim/os_unix.h"
#include "nvim/path.h"
#include "nvim/ui.h"
#include "nvim/os/os.h"

#define MEMFILE_PAGE_SIZE 4096       /// default page size


static long_u total_mem_used = 0;    /// total memory used for memfiles

#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "memfile.c.generated.h"
#endif

/// Open a new or existing memory block file.
///
/// @param fname  Name of file to use.
///               - If NULL, it means no file (use memory only).
///               - If not NULL:
///                 * Should correspond to an existing file.
///                 * String must have been allocated (it is not copied).
///                 * If opening the file fails, it is freed and function fails.

/// @param flags  Flags for open() call.
///
/// @return - The open memory file, on success.
///         - NULL, on failure.
memfile_T *mf_open(char_u *fname, int flags)
{
  off_t size;

  memfile_T *mfp = xmalloc(sizeof(memfile_T));

  if (fname == NULL) {               // no file, use memory only
    mfp->mf_fname = NULL;
    mfp->mf_ffname = NULL;
    mfp->mf_fd = -1;
  } else {                           // try to open the file
    mf_do_open(mfp, fname, flags);

    if (mfp->mf_fd < 0) {            // fail if file could not be opened
      free(mfp);
      return NULL;
    }
  }

  mfp->mf_free_first = NULL;         // free list is empty
  mfp->mf_used_first = NULL;         // used list is empty
  mfp->mf_used_last = NULL;
  mfp->mf_dirty = FALSE;
  mfp->mf_used_count = 0;
  mf_hash_init(&mfp->mf_hash);
  mf_hash_init(&mfp->mf_trans);
  mfp->mf_page_size = MEMFILE_PAGE_SIZE;

  // Try to set the page size equal to device's block size. Speeds up I/O a lot.
  FileInfo file_info;
  if (mfp->mf_fd >= 0 && os_fileinfo_fd(mfp->mf_fd, &file_info)) {
    uint64_t blocksize = os_fileinfo_blocksize(&file_info);
    if (blocksize >= MIN_SWAP_PAGE_SIZE && blocksize <= MAX_SWAP_PAGE_SIZE) {
      assert(blocksize <= UINT_MAX);
      mfp->mf_page_size = (unsigned)blocksize;
    }
  }

  // When recovering, the actual block size will be retrieved from block 0
  // in ml_recover(). The size used here may be wrong, therefore mf_blocknr_max
  // must be rounded up.
  if (mfp->mf_fd < 0
      || (flags & (O_TRUNC|O_EXCL))
      || (size = lseek(mfp->mf_fd, (off_t)0L, SEEK_END)) <= 0)
    // no file or empty file
    mfp->mf_blocknr_max = 0;
  else
    mfp->mf_blocknr_max = (blocknr_T)((size + mfp->mf_page_size - 1)
                                      / mfp->mf_page_size);
  mfp->mf_blocknr_min = -1;
  mfp->mf_neg_count = 0;
  mfp->mf_infile_count = mfp->mf_blocknr_max;

  // Compute maximum number of pages ('maxmem' is in Kbytes):
  //	'mammem' * 1Kbyte / page-size-in-bytes.
  // Avoid overflow by first reducing page size as much as possible.
  {
    int shift = 10;
    unsigned page_size = mfp->mf_page_size;

    while (shift > 0 && (page_size & 1) == 0) {
      page_size /= 2;
      --shift;
    }

    assert(p_mm << shift >= p_mm);  // check we don't overflow
    assert(p_mm < UINT_MAX);        // check we can cast to unsigned
    mfp->mf_used_count_max = (unsigned)(p_mm << shift) / page_size;
    if (mfp->mf_used_count_max < 10)
      mfp->mf_used_count_max = 10;
  }

  return mfp;
}

/// Open a file for an existing memfile.
///
/// Used when updatecount set from 0 to some value.
///
/// @param fname  Name of file to use.
///               - If NULL, it means no file (use memory only).
///               - If not NULL:
///                 * Should correspond to an existing file.
///                 * String must have been allocated (it is not copied).
///                 * If opening the file fails, it is freed and function fails.
///
/// @return OK    On success.
///         FAIL  If file could not be opened.
int mf_open_file(memfile_T *mfp, char_u *fname)
{
  mf_do_open(mfp, fname, O_RDWR|O_CREAT|O_EXCL);  // try to open the file

  if (mfp->mf_fd < 0)
    return FAIL;

  mfp->mf_dirty = TRUE;
  return OK;
}

/// Close a memory file and optionally delete the associated file.
///
/// @param del_file  TRUE to delete associated file.
void mf_close(memfile_T *mfp, int del_file)
{
  bhdr_T      *hp, *nextp;

  if (mfp == NULL) {                    // safety check
    return;
  }
  if (mfp->mf_fd >= 0 && close(mfp->mf_fd) < 0) {
      EMSG(_(e_swapclose));
  }
  if (del_file && mfp->mf_fname != NULL)
    os_remove((char *)mfp->mf_fname);
  // free entries in used list
  for (hp = mfp->mf_used_first; hp != NULL; hp = nextp) {
    total_mem_used -= hp->bh_page_count * mfp->mf_page_size;
    nextp = hp->bh_next;
    mf_free_bhdr(hp);
  }
  while (mfp->mf_free_first != NULL)    // free entries in free list
    free(mf_rem_free(mfp));
  mf_hash_free(&mfp->mf_hash);
  mf_hash_free_all(&mfp->mf_trans);     // free hashtable and its items
  free(mfp->mf_fname);
  free(mfp->mf_ffname);
  free(mfp);
}

/// Close the swap file for a memfile. Used when 'swapfile' is reset.
///
/// @param getlines  TRUE to get all lines into memory.
void mf_close_file (buf_T *buf, int getlines)
{
  memfile_T *mfp = buf->b_ml.ml_mfp;
  if (mfp == NULL || mfp->mf_fd < 0)     // nothing to close
    return;

  if (getlines) {
    // get all blocks in memory by accessing all lines (clumsy!)
    mf_dont_release = TRUE;
    for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum)
      (void)ml_get_buf(buf, lnum, FALSE);
    mf_dont_release = FALSE;
    // TODO: should check if all blocks are really in core
  }

  if (close(mfp->mf_fd) < 0)             // close the file
    EMSG(_(e_swapclose));
  mfp->mf_fd = -1;

  if (mfp->mf_fname != NULL) {
    os_remove((char *)mfp->mf_fname);    // delete the swap file
    free(mfp->mf_fname);
    free(mfp->mf_ffname);
    mfp->mf_fname = NULL;
    mfp->mf_ffname = NULL;
  }
}

/// Set new size for a memfile. Used when block 0 of a swapfile has been read
/// and the size it indicates differs from what was guessed.
void mf_new_page_size(memfile_T *mfp, unsigned new_size)
{
  // Correct the memory used for block 0 to the new size, because it will be
  // freed with that size later on.
  total_mem_used += new_size - mfp->mf_page_size;
  mfp->mf_page_size = new_size;
}

/// Get a new block
/// 
/// @param negative    TRUE if negative block number desired (data block)
/// @param page_count  Desired number of pages.
bhdr_T *mf_new(memfile_T *mfp, int negative, unsigned page_count)
{
  // If we reached the maximum size for the used memory blocks, release one.
  // If a bhdr_T is returned, use it and adjust the page_count if necessary.
  // If no bhdr_T is returned, a new one will be created.
  bhdr_T *hp = mf_release(mfp, page_count);  // the block to be returned

  // Decide on the number to use:
  // If there is a free block, use its number.
  // Otherwise use mf_block_min for a negative number, mf_block_max for
  // a positive number.
  bhdr_T *freep = mfp->mf_free_first;        // first free block
  if (!negative && freep != NULL && freep->bh_page_count >= page_count) {
    // If the block in the free list has more pages, take only the number
    // of pages needed and allocate a new bhdr_T with data.
    // 
    // If the number of pages matches and mf_release() did not return a
    // bhdr_T, use the bhdr_T from the free list and allocate the data.
    // 
    // If the number of pages matches and mf_release() returned a bhdr_T,
    // just use the number and free the bhdr_T from the free list
    if (freep->bh_page_count > page_count) {
      if (hp == NULL) {
        hp = mf_alloc_bhdr(mfp, page_count);
      }
      hp->bh_bnum = freep->bh_bnum;
      freep->bh_bnum += page_count;
      freep->bh_page_count -= page_count;
    } else if (hp == NULL) {    // need to allocate memory for this block
      char_u *p = xmalloc(mfp->mf_page_size * page_count);
      hp = mf_rem_free(mfp);
      hp->bh_data = p;
    } else {                    // use the number, remove entry from free list
      freep = mf_rem_free(mfp);
      hp->bh_bnum = freep->bh_bnum;
      free(freep);
    }
  } else {                      // get a new number
    if (hp == NULL) {
      hp = mf_alloc_bhdr(mfp, page_count);
    }
    if (negative) {
      hp->bh_bnum = mfp->mf_blocknr_min--;
      mfp->mf_neg_count++;
    } else {
      hp->bh_bnum = mfp->mf_blocknr_max;
      mfp->mf_blocknr_max += page_count;
    }
  }
  hp->bh_flags = BH_LOCKED | BH_DIRTY;    // new block is always dirty
  mfp->mf_dirty = TRUE;
  hp->bh_page_count = page_count;
  mf_ins_used(mfp, hp);
  mf_ins_hash(mfp, hp);

  // Init the data to all zero, to avoid reading uninitialized data.
  // This also avoids that the passwd file ends up in the swap file!
  (void)memset((char *)(hp->bh_data), 0, mfp->mf_page_size * page_count);

  return hp;
}

// Get existing block "nr" with "page_count" pages.
//
// Caller should first check a negative nr with mf_trans_del().
//
// @return  NULL if not found
bhdr_T *mf_get(memfile_T *mfp, blocknr_T nr, unsigned page_count)
{
  // check block number exists
  if (nr >= mfp->mf_blocknr_max || nr <= mfp->mf_blocknr_min)
    return NULL;

  // see if it is in the cache
  bhdr_T *hp = mf_find_hash(mfp, nr);
  if (hp == NULL) {                             // not in the hash list
    if (nr < 0 || nr >= mfp->mf_infile_count)   // can't be in the file
      return NULL;

    // could check here if the block is in the free list

    // Check if we need to flush an existing block.
    // If so, use that block.
    // If not, allocate a new block.
    hp = mf_release(mfp, page_count);
    if (hp == NULL) {
      hp = mf_alloc_bhdr(mfp, page_count);
    }

    hp->bh_bnum = nr;
    hp->bh_flags = 0;
    hp->bh_page_count = page_count;
    if (mf_read(mfp, hp) == FAIL) {             // cannot read the block
      mf_free_bhdr(hp);
      return NULL;
    }
  } else {
    mf_rem_used(mfp, hp);       // remove from list, insert in front below
    mf_rem_hash(mfp, hp);
  }

  hp->bh_flags |= BH_LOCKED;
  mf_ins_used(mfp, hp);         // put in front of used list
  mf_ins_hash(mfp, hp);         // put in front of hash list

  return hp;
}

/// Release the block *hp.
/// 
/// @param dirty   Block must be written to file later.
/// @param infile  Block should be in file (needed for recovery).
void mf_put(memfile_T *mfp, bhdr_T *hp, int dirty, int infile)
{
  unsigned flags = hp->bh_flags;

  if ((flags & BH_LOCKED) == 0)
    EMSG(_("E293: block was not locked"));
  flags &= ~BH_LOCKED;
  if (dirty) {
    flags |= BH_DIRTY;
    mfp->mf_dirty = TRUE;
  }
  hp->bh_flags = flags;
  if (infile)
    mf_trans_add(mfp, hp);      // may translate negative in positive nr
}

/// Signal block as no longer used (may put it in the free list).
void mf_free(memfile_T *mfp, bhdr_T *hp)
{
  free(hp->bh_data);            // free data
  mf_rem_hash(mfp, hp);         // get *hp out of the hash list
  mf_rem_used(mfp, hp);         // get *hp out of the used list
  if (hp->bh_bnum < 0) {
    free(hp);                   // don't want negative numbers in free list
    mfp->mf_neg_count--;
  } else
    mf_ins_free(mfp, hp);       // put *hp in the free list
}

/// Sync memory file to disk.
///
/// @param flags  MFS_ALL    If not given, blocks with negative numbers are not
///                          synced, even when they are dirty.
///               MFS_STOP   Stop syncing when a character becomes available,
///                          but sync at least one block.
///               MFS_FLUSH  Make sure buffers are flushed to disk, so they will
///                          survive a system crash.
///               MFS_ZERO   Only write block 0.
/// 
/// @return FAIL  If failure. Possible causes:
///               - No file (nothing to do).
///               - Write error (probably full disk).
///         OK    Otherwise.
int mf_sync(memfile_T *mfp, int flags)
{
  int got_int_save = got_int;

  if (mfp->mf_fd < 0) {         // there is no file, nothing to do
    mfp->mf_dirty = FALSE;
    return FAIL;
  }

  // Only a CTRL-C while writing will break us here, not one typed previously.
  got_int = FALSE;

  // Sync from last to first (may reduce the probability of an inconsistent
  // file). If a write fails, it is very likely caused by a full filesystem.
  // Then we only try to write blocks within the existing file. If that also
  // fails then we give up.
  int status = OK;
  bhdr_T *hp;
  for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
    if (((flags & MFS_ALL) || hp->bh_bnum >= 0)
        && (hp->bh_flags & BH_DIRTY)
        && (status == OK || (hp->bh_bnum >= 0
                             && hp->bh_bnum < mfp->mf_infile_count))) {
      if ((flags & MFS_ZERO) && hp->bh_bnum != 0)
        continue;
      if (mf_write(mfp, hp) == FAIL) {
        if (status == FAIL)     // double error: quit syncing
          break;
        status = FAIL;
      }
      if (flags & MFS_STOP) {   // Stop when char available now.
        if (ui_char_avail())
          break;
      } else
        ui_breakcheck();
      if (got_int)
        break;
    }

  // If the whole list is flushed, the memfile is not dirty anymore.
  // In case of an error, dirty flag is also set, to avoid trying all the time.
  if (hp == NULL || status == FAIL)
    mfp->mf_dirty = FALSE;

  if ((flags & MFS_FLUSH) && *p_sws != NUL) {
#if defined(UNIX)
# ifdef HAVE_FSYNC
    if (STRCMP(p_sws, "fsync") == 0) {
      if (fsync(mfp->mf_fd))
        status = FAIL;
    } else
# endif
    // OpenNT is strictly POSIX (Benzinger).
    // Tandem/Himalaya NSK-OSS doesn't have sync()
# if defined(__OPENNT) || defined(__TANDEM)
    fflush(NULL);
# else
    sync();
# endif
#endif
# ifdef SYNC_DUP_CLOSE
    // Win32 is a bit more work: Duplicate the file handle and close it.
    // This should flush the file to disk.
    int fd;
    if ((fd = dup(mfp->mf_fd)) >= 0)
      close(fd);
# endif
  }

  got_int |= got_int_save;

  return status;
}

/// Set dirty flag for all blocks in memory file with a positive block number.
/// These are blocks that need to be written to a newly created swapfile.
void mf_set_dirty(memfile_T *mfp)
{
  bhdr_T *hp;
  for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
    if (hp->bh_bnum > 0)
      hp->bh_flags |= BH_DIRTY;
  mfp->mf_dirty = TRUE;
}

/// Insert block in front of memfile's hash list.
static void mf_ins_hash(memfile_T *mfp, bhdr_T *hp)
{
  mf_hash_add_item(&mfp->mf_hash, (mf_hashitem_T *)hp);
}

/// Remove block from memfile's hash list.
static void mf_rem_hash(memfile_T *mfp, bhdr_T *hp)
{
  mf_hash_rem_item(&mfp->mf_hash, (mf_hashitem_T *)hp);
}

/// Lookup block with number "nr" in memfile's hash list.
static bhdr_T *mf_find_hash(memfile_T *mfp, blocknr_T nr)
{
  return (bhdr_T *)mf_hash_find(&mfp->mf_hash, nr);
}

/// Insert block at the front of memfile's used list.
static void mf_ins_used(memfile_T *mfp, bhdr_T *hp)
{
  hp->bh_next = mfp->mf_used_first;
  mfp->mf_used_first = hp;
  hp->bh_prev = NULL;
  if (hp->bh_next == NULL)      // list was empty, adjust last pointer
    mfp->mf_used_last = hp;
  else
    hp->bh_next->bh_prev = hp;
  mfp->mf_used_count += hp->bh_page_count;
  total_mem_used += hp->bh_page_count * mfp->mf_page_size;
}

/// Remove block from memfile's used list.
static void mf_rem_used(memfile_T *mfp, bhdr_T *hp)
{
  if (hp->bh_next == NULL)                 // last block in used list
    mfp->mf_used_last = hp->bh_prev;
  else
    hp->bh_next->bh_prev = hp->bh_prev;

  if (hp->bh_prev == NULL)                 // first block in used list
    mfp->mf_used_first = hp->bh_next;
  else
    hp->bh_prev->bh_next = hp->bh_next;

  mfp->mf_used_count -= hp->bh_page_count;
  total_mem_used -= hp->bh_page_count * mfp->mf_page_size;
}

/// Try to release the least recently used block from the used list if the
/// number of used memory blocks gets too big.
/// 
/// @return  The block header, when release needed and possible.
///              Resulting block header includes memory block, so it can be
///              reused.  Page count is checked to be right.
///          NULL, when release not needed, or not possible.
///              Not needed when number of blocks less than allowed maximum and
///              total memory used below 'maxmemtot'.
///              Not possible when:
///              - Called while closing file.
///              - Tried to create swap file but couldn't.
///              - All blocks are locked.
///              - Unlocked dirty block found, but flush failed.
static bhdr_T *mf_release(memfile_T *mfp, unsigned page_count)
{
  // don't release while in mf_close_file()
  if (mf_dont_release)
    return NULL;

  /// Need to release a block if the number of blocks for this memfile is
  /// higher than the maximum one or total memory used is over 'maxmemtot'.
  int need_release = (mfp->mf_used_count >= mfp->mf_used_count_max
                      || (total_mem_used >> 10) >= (long_u)p_mmt);

  /// Try to create swap file if the amount of memory used is getting too high.
  if (mfp->mf_fd < 0 && need_release && p_uc) {
    // find for which buffer this memfile is
    buf_T *buf = NULL;
    FOR_ALL_BUFFERS(bp) {
      if (bp->b_ml.ml_mfp == mfp) {
        buf = bp;
        break;
      }
    }
    if (buf != NULL && buf->b_may_swap) {
      ml_open_file(buf);
    }
  }

  /// Don't release a block if:
  ///     there is no file for this memfile
  ///     or
  ///         the number of blocks for this memfile is lower than the maximum
  ///         and
  ///         total memory used is not up to 'maxmemtot'
  if (mfp->mf_fd < 0 || !need_release)
    return NULL;

  bhdr_T *hp;
  for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev)
    if (!(hp->bh_flags & BH_LOCKED))
      break;
  if (hp == NULL)       // not a single one that can be released
    return NULL;

  // If the block is dirty, write it.
  // If the write fails we don't free it.
  if ((hp->bh_flags & BH_DIRTY) && mf_write(mfp, hp) == FAIL)
    return NULL;

  mf_rem_used(mfp, hp);
  mf_rem_hash(mfp, hp);

  /// Make sure page_count of bh_data is right.
  if (hp->bh_page_count != page_count) {
    free(hp->bh_data);
    hp->bh_data = xmalloc(mfp->mf_page_size * page_count);
    hp->bh_page_count = page_count;
  }
  return hp;
}

/// Release as many blocks as possible.
///
/// Used in case of out of memory
/// 
/// @return  TRUE   If any memory was released.
///          FALSE  If not.
int mf_release_all(void)
{
  int retval = FALSE;
  FOR_ALL_BUFFERS(buf) {
    memfile_T *mfp = buf->b_ml.ml_mfp;
    if (mfp != NULL) {
      // If no swap file yet, may open one.
      if (mfp->mf_fd < 0 && buf->b_may_swap)
        ml_open_file(buf);

      // Flush as many blocks as possible, only if there is a swapfile.
      if (mfp->mf_fd >= 0) {
        for (bhdr_T *hp = mfp->mf_used_last; hp != NULL; ) {
          if (!(hp->bh_flags & BH_LOCKED)
              && (!(hp->bh_flags & BH_DIRTY)
                  || mf_write(mfp, hp) != FAIL)) {
            mf_rem_used(mfp, hp);
            mf_rem_hash(mfp, hp);
            mf_free_bhdr(hp);
            hp = mfp->mf_used_last;    // restart, list was changed
            retval = TRUE;
          } else
            hp = hp->bh_prev;
        }
      }
    }
  }
  return retval;
}

/// Allocate a block header and a block of memory for it.
static bhdr_T *mf_alloc_bhdr(memfile_T *mfp, unsigned page_count)
{
  bhdr_T *hp = xmalloc(sizeof(bhdr_T));
  hp->bh_data = xmalloc(mfp->mf_page_size * page_count);
  hp->bh_page_count = page_count;
  return hp;
}

/// Free a block header and its block memory.
static void mf_free_bhdr(bhdr_T *hp)
{
  free(hp->bh_data);
  free(hp);
}

/// Insert a block in the free list.
static void mf_ins_free(memfile_T *mfp, bhdr_T *hp)
{
  hp->bh_next = mfp->mf_free_first;
  mfp->mf_free_first = hp;
}

/// Remove the first block in the free list and return it.
///
/// Caller must check that mfp->mf_free_first is not NULL.
static bhdr_T *mf_rem_free(memfile_T *mfp)
{
  bhdr_T *hp = mfp->mf_free_first;
  mfp->mf_free_first = hp->bh_next;
  return hp;
}

/// Read a block from disk.
/// 
/// @return  OK    On success.
///          FAIL  On failure. Could be:
///                - No file.
///                - Error reading file.
static int mf_read(memfile_T *mfp, bhdr_T *hp)
{
  if (mfp->mf_fd < 0)       // there is no file, can't read
    return FAIL;

  unsigned page_size = mfp->mf_page_size;
  off_t offset = (off_t)page_size * hp->bh_bnum;
  unsigned size = page_size * hp->bh_page_count;
  if (lseek(mfp->mf_fd, offset, SEEK_SET) != offset) {
    PERROR(_("E294: Seek error in swap file read"));
    return FAIL;
  }
  if ((unsigned)read_eintr(mfp->mf_fd, hp->bh_data, size) != size) {
    PERROR(_("E295: Read error in swap file"));
    return FAIL;
  }

  return OK;
}

/// Write a block to disk.
/// 
/// @return  OK    On success.
///          FAIL  On failure. Could be:
///                - No file.
///                - Could not translate negative block number to positive.
///                - Seek error in swap file.
///                - Write error in swap file.
static int mf_write(memfile_T *mfp, bhdr_T *hp)
{
  off_t offset;             // offset in the file
  blocknr_T nr;             // block nr which is being written
  bhdr_T *hp2;
  unsigned page_size;       // number of bytes in a page
  unsigned page_count;      // number of pages written
  unsigned size;            // number of bytes written

  if (mfp->mf_fd < 0)       // there is no file, can't write
    return FAIL;

  if (hp->bh_bnum < 0)      // must assign file block number
    if (mf_trans_add(mfp, hp) == FAIL)
      return FAIL;

  page_size = mfp->mf_page_size;

  /// We don't want gaps in the file. Write the blocks in front of *hp
  /// to extend the file.
  /// If block 'mf_infile_count' is not in the hash list, it has been
  /// freed. Fill the space in the file with data from the current block.
  for (;;) {
    nr = hp->bh_bnum;
    if (nr > mfp->mf_infile_count) {            // beyond end of file
      nr = mfp->mf_infile_count;
      hp2 = mf_find_hash(mfp, nr);              // NULL caught below
    } else
      hp2 = hp;

    offset = (off_t)page_size * nr;
    if (lseek(mfp->mf_fd, offset, SEEK_SET) != offset) {
      PERROR(_("E296: Seek error in swap file write"));
      return FAIL;
    }
    if (hp2 == NULL)                // freed block, fill with dummy data
      page_count = 1;
    else
      page_count = hp2->bh_page_count;
    size = page_size * page_count;
    if (mf_write_block(mfp, hp2 == NULL ? hp : hp2, offset, size) == FAIL) {
      /// Avoid repeating the error message, this mostly happens when the
      /// disk is full. We give the message again only after a successful
      /// write or when hitting a key. We keep on trying, in case some
      /// space becomes available.
      if (!did_swapwrite_msg)
        EMSG(_("E297: Write error in swap file"));
      did_swapwrite_msg = TRUE;
      return FAIL;
    }
    did_swapwrite_msg = FALSE;
    if (hp2 != NULL)                               // written a non-dummy block
      hp2->bh_flags &= ~BH_DIRTY;
    if (nr + (blocknr_T)page_count > mfp->mf_infile_count)  // appended to file
      mfp->mf_infile_count = nr + page_count;
    if (nr == hp->bh_bnum)                         // written the desired block
      break;
  }
  return OK;
}

/// Write block to memfile's file.
///
/// @return  OK    On success.
///          FAIL  On failure.
static int mf_write_block(memfile_T *mfp, bhdr_T *hp,
                          off_t offset, unsigned size)
{
  char_u *data = hp->bh_data;
  int result = OK;
  if ((unsigned)write_eintr(mfp->mf_fd, data, size) != size)
    result = FAIL;
  return result;
}

/// Make block number positive and add it to the translation list.
/// 
/// @return  OK    On success.
///          FAIL  On failure.
static int mf_trans_add(memfile_T *mfp, bhdr_T *hp)
{
  if (hp->bh_bnum >= 0)                     // it's already positive
    return OK;

  mf_blocknr_trans_item_T *np = xmalloc(sizeof(mf_blocknr_trans_item_T));

  // Get a new number for the block.
  // If the first item in the free list has sufficient pages, use its number.
  // Otherwise use mf_blocknr_max.
  blocknr_T new_bnum;
  bhdr_T *freep = mfp->mf_free_first;
  unsigned page_count = hp->bh_page_count;
  if (freep != NULL && freep->bh_page_count >= page_count) {
    new_bnum = freep->bh_bnum;
    // If the page count of the free block was larger, reduce it.
    // If the page count matches, remove the block from the free list.
    if (freep->bh_page_count > page_count) {
      freep->bh_bnum += page_count;
      freep->bh_page_count -= page_count;
    } else {
      freep = mf_rem_free(mfp);
      free(freep);
    }
  } else {
    new_bnum = mfp->mf_blocknr_max;
    mfp->mf_blocknr_max += page_count;
  }

  np->nt_old_bnum = hp->bh_bnum;            // adjust number
  np->nt_new_bnum = new_bnum;

  mf_rem_hash(mfp, hp);                     // remove from old hash list
  hp->bh_bnum = new_bnum;
  mf_ins_hash(mfp, hp);                     // insert in new hash list

  // Insert "np" into "mf_trans" hashtable with key "np->nt_old_bnum".
  mf_hash_add_item(&mfp->mf_trans, (mf_hashitem_T *)np);

  return OK;
}

/// Lookup translation from trans list and delete the entry.
/// 
/// @return  The positive new number  When found.
///          The old number           When not found.
blocknr_T mf_trans_del(memfile_T *mfp, blocknr_T old_nr)
{
  mf_blocknr_trans_item_T *np =
    (mf_blocknr_trans_item_T *)mf_hash_find(&mfp->mf_trans, old_nr);

  if (np == NULL)    // not found
    return old_nr;

  mfp->mf_neg_count--;
  blocknr_T new_bnum = np->nt_new_bnum;

  // remove entry from the trans list
  mf_hash_rem_item(&mfp->mf_trans, (mf_hashitem_T *)np);

  free(np);

  return new_bnum;
}

/// Set full file name of memfile's swapfile, out of simple file name and some
/// other considerations.
///
/// Only called when creating or renaming the swapfile. Either way it's a new
/// name so we must work out the full path name.
void mf_set_ffname(memfile_T *mfp)
{
  mfp->mf_ffname = FullName_save(mfp->mf_fname, FALSE);
}

/// Make name of memfile's swapfile a full path.
///
/// Used before doing a :cd
void mf_fullname(memfile_T *mfp)
{
  if (mfp != NULL && mfp->mf_fname != NULL && mfp->mf_ffname != NULL) {
    free(mfp->mf_fname);
    mfp->mf_fname = mfp->mf_ffname;
    mfp->mf_ffname = NULL;
  }
}

/// Return TRUE if there are any translations pending for memfile.
int mf_need_trans(memfile_T *mfp)
{
  return mfp->mf_fname != NULL && mfp->mf_neg_count > 0;
}

/// Open memfile's swapfile.
///
/// "fname" must be in allocated memory, and is consumed (also when error).
///
/// @param  flags  Flags for open().
static void mf_do_open (memfile_T *mfp, char_u *fname, int flags)
{
  // fname cannot be NameBuff, because it must have been allocated.
  mfp->mf_fname = fname;
  mf_set_ffname(mfp);

  /// Extra security check: When creating a swap file it really shouldn't
  /// exist yet. If there is a symbolic link, this is most likely an attack.
  FileInfo file_info;
  if ((flags & O_CREAT)
      && os_fileinfo_link((char *)mfp->mf_fname, &file_info)) {
    mfp->mf_fd = -1;
    EMSG(_("E300: Swap file already exists (symlink attack?)"));
  } else {
    // try to open the file
    flags |= O_NOFOLLOW;
    mfp->mf_fd = mch_open_rw((char *)mfp->mf_fname, flags);
  }

  // If the file cannot be opened, use memory only
  if (mfp->mf_fd < 0) {
    free(mfp->mf_fname);
    free(mfp->mf_ffname);
    mfp->mf_fname = NULL;
    mfp->mf_ffname = NULL;
  } else {
#ifdef HAVE_FD_CLOEXEC
    int fdflags = fcntl(mfp->mf_fd, F_GETFD);
    if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0)
      fcntl(mfp->mf_fd, F_SETFD, fdflags | FD_CLOEXEC);
#endif
#ifdef HAVE_SELINUX
    mch_copy_sec(fname, mfp->mf_fname);
#endif
    mch_hide(mfp->mf_fname);        // try setting the 'hidden' flag
  }
}

// 
// Implementation of mf_hashtab_T.
// 

/// The number of buckets in the hashtable is increased by a factor of
/// MHT_GROWTH_FACTOR when the average number of items per bucket
/// exceeds 2 ^ MHT_LOG_LOAD_FACTOR.
#define MHT_LOG_LOAD_FACTOR 6
#define MHT_GROWTH_FACTOR   2   // must be a power of two

/// Initialize an empty hash table.
static void mf_hash_init(mf_hashtab_T *mht)
{
  memset(mht, 0, sizeof(mf_hashtab_T));
  mht->mht_buckets = mht->mht_small_buckets;
  mht->mht_mask = MHT_INIT_SIZE - 1;
}

/// Free the array of a hash table. Does not free the items it contains!
/// The hash table must not be used again without another mf_hash_init() call.
static void mf_hash_free(mf_hashtab_T *mht)
{
  if (mht->mht_buckets != mht->mht_small_buckets)
    free(mht->mht_buckets);
}

/// Free the array of a hash table and all the items it contains.
static void mf_hash_free_all(mf_hashtab_T *mht)
{
  mf_hashitem_T *next;

  for (long_u idx = 0; idx <= mht->mht_mask; idx++)
    for (mf_hashitem_T *mhi = mht->mht_buckets[idx]; mhi != NULL; mhi = next) {
      next = mhi->mhi_next;
      free(mhi);
    }

  mf_hash_free(mht);
}

/// Find by key.
///
/// @return  A pointer to a mf_hashitem_T or NULL if the item was not found.
static mf_hashitem_T *mf_hash_find(mf_hashtab_T *mht, blocknr_T key)
{
  mf_hashitem_T *mhi = mht->mht_buckets[(unsigned long)key & mht->mht_mask];
  while (mhi != NULL && mhi->mhi_key != key)
    mhi = mhi->mhi_next;
  return mhi;
}

/// Add item to hashtable. Item must not be NULL.
static void mf_hash_add_item(mf_hashtab_T *mht, mf_hashitem_T *mhi)
{
  long_u idx = (unsigned long)mhi->mhi_key & mht->mht_mask;
  mhi->mhi_next = mht->mht_buckets[idx];
  mhi->mhi_prev = NULL;
  if (mhi->mhi_next != NULL)
    mhi->mhi_next->mhi_prev = mhi;
  mht->mht_buckets[idx] = mhi;

  mht->mht_count++;

  /// Grow hashtable when we have more thank 2^MHT_LOG_LOAD_FACTOR
  /// items per bucket on average.
  if (mht->mht_fixed == 0
      && (mht->mht_count >> MHT_LOG_LOAD_FACTOR) > mht->mht_mask) {
    mf_hash_grow(mht);
  }
}

/// Remove item from hashtable. Item must be non NULL and within hashtable.
static void mf_hash_rem_item(mf_hashtab_T *mht, mf_hashitem_T *mhi)
{
  if (mhi->mhi_prev == NULL)
    mht->mht_buckets[(unsigned long)mhi->mhi_key & mht->mht_mask] =
      mhi->mhi_next;
  else
    mhi->mhi_prev->mhi_next = mhi->mhi_next;

  if (mhi->mhi_next != NULL)
    mhi->mhi_next->mhi_prev = mhi->mhi_prev;

  mht->mht_count--;

  // We could shrink the table here, but it typically takes little memory,
  // so why bother?
}

/// Increase number of buckets in the hashtable by MHT_GROWTH_FACTOR and
/// rehash items.
static void mf_hash_grow(mf_hashtab_T *mht)
{
  size_t size = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR * sizeof(void *);
  mf_hashitem_T **buckets = xcalloc(1, size);

  int shift = 0;
  while ((mht->mht_mask >> shift) != 0)
    shift++;

  for (long_u i = 0; i <= mht->mht_mask; i++) {
    /// Traverse the items in the i-th original bucket and move them into
    /// MHT_GROWTH_FACTOR new buckets, preserving their relative order
    /// within each new bucket. Preserving the order is important because
    /// mf_get() tries to keep most recently used items at the front of
    /// each bucket.
    /// 
    /// Here we strongly rely on the fact that hashes are computed modulo
    /// a power of two.

    mf_hashitem_T *tails[MHT_GROWTH_FACTOR];
    memset(tails, 0, sizeof(tails));

    for (mf_hashitem_T *mhi = mht->mht_buckets[i];
         mhi != NULL; mhi = mhi->mhi_next) {
      long_u j = (mhi->mhi_key >> shift) & (MHT_GROWTH_FACTOR - 1);
      if (tails[j] == NULL) {
        buckets[i + (j << shift)] = mhi;
        tails[j] = mhi;
        mhi->mhi_prev = NULL;
      } else {
        tails[j]->mhi_next = mhi;
        mhi->mhi_prev = tails[j];
        tails[j] = mhi;
      }
    }

    for (long_u j = 0; j < MHT_GROWTH_FACTOR; j++)
      if (tails[j] != NULL)
        tails[j]->mhi_next = NULL;
  }

  if (mht->mht_buckets != mht->mht_small_buckets)
    free(mht->mht_buckets);

  mht->mht_buckets = buckets;
  mht->mht_mask = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR - 1;
}