path: root/src/nvim/memfile.c

// This is an open source non-commercial project. Dear PVS-Studio, please check
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com

/// 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 <inttypes.h>
#include <limits.h>
#include <string.h>
#include <stdbool.h>
#include <fcntl.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/memory.h"
#include "nvim/os_unix.h"
#include "nvim/path.h"
#include "nvim/assert.h"
#include "nvim/os/os.h"
#include "nvim/os/input.h"

#define MEMFILE_PAGE_SIZE 4096       /// default page size


#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.
memfile_T *mf_open(char_u *fname, int flags)
{
  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
    if (!mf_do_open(mfp, fname, flags)) {
      xfree(mfp);
      return NULL;                   // fail if file could not be opened
    }
  }

  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;
  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) {
      STATIC_ASSERT(MAX_SWAP_PAGE_SIZE <= UINT_MAX,
                    "MAX_SWAP_PAGE_SIZE must fit into an unsigned");
      mfp->mf_page_size = (unsigned)blocksize;
    }
  }

  off_T size;

  // 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 = vim_lseek(mfp->mf_fd, 0L, SEEK_END)) <= 0) {
    // no file or empty file
    mfp->mf_blocknr_max = 0;
  } else {
    assert(sizeof(off_T) <= sizeof(blocknr_T)
           && mfp->mf_page_size > 0
           && mfp->mf_page_size - 1 <= INT64_MAX - size);
    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;

  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)
{
  if (mf_do_open(mfp, fname, O_RDWR | O_CREAT | O_EXCL)) {
    mfp->mf_dirty = true;
    return OK;
  }

  return FAIL;
}

/// Close a memory file and optionally delete the associated file.
///
/// @param del_file  Whether to delete associated file.
void mf_close(memfile_T *mfp, bool del_file)
{
  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 (bhdr_T *hp = mfp->mf_used_first, *nextp; hp != NULL; hp = nextp) {
    nextp = hp->bh_next;
    mf_free_bhdr(hp);
  }
  while (mfp->mf_free_first != NULL) {  // free entries in free list
    xfree(mf_rem_free(mfp));
  }
  mf_hash_free(&mfp->mf_hash);
  mf_hash_free_all(&mfp->mf_trans);     // free hashtable and its items
  mf_free_fnames(mfp);
  xfree(mfp);
}

/// Close the swap file for a memfile. Used when 'swapfile' is reset.
///
/// @param getlines  Whether to get all lines into memory.
void mf_close_file(buf_T *buf, bool 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!)
    for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
      (void)ml_get_buf(buf, lnum, false);
    }
  }

  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
    mf_free_fnames(mfp);
  }
}

/// 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)
{
  mfp->mf_page_size = new_size;
}

/// Get a new block
///
/// @param negative    Whether a negative block number is desired (data block).
/// @param page_count  Desired number of pages.
bhdr_T *mf_new(memfile_T *mfp, bool negative, unsigned page_count)
{
  bhdr_T *hp = NULL;

  // 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 (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.
      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 {    // need to allocate memory for this block
      // If the number of pages matches use the bhdr_T from the free list and
      // allocate the data.
      void *p = xmalloc(mfp->mf_page_size * page_count);
      hp = mf_rem_free(mfp);
      hp->bh_data = p;
    }
  } else {                      // get a new number
    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(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) {