diff options
Diffstat (limited to 'src/memfile.c')
| -rw-r--r-- | src/memfile.c | 1260 |
1 files changed, 0 insertions, 1260 deletions
diff --git a/src/memfile.c b/src/memfile.c deleted file mode 100644 index 9431101d8d..0000000000 --- a/src/memfile.c +++ /dev/null @@ -1,1260 +0,0 @@ -/* - * 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. - */ - -/* - * memfile.c: Contains the functions for handling 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. The 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. The - * 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. - */ - -#include <string.h> - -#include "vim.h" -#include "memfile.h" -#include "fileio.h" -#include "memline.h" -#include "message.h" -#include "misc1.h" -#include "misc2.h" -#include "memory.h" -#include "os_unix.h" -#include "path.h" -#include "ui.h" -#include "os/os.h" - -#define MEMFILE_PAGE_SIZE 4096 /* default page size */ - -static long_u total_mem_used = 0; /* total memory used for memfiles */ - -static void mf_ins_hash(memfile_T *, bhdr_T *); -static void mf_rem_hash(memfile_T *, bhdr_T *); -static bhdr_T *mf_find_hash(memfile_T *, blocknr_T); -static void mf_ins_used(memfile_T *, bhdr_T *); -static void mf_rem_used(memfile_T *, bhdr_T *); -static bhdr_T *mf_release(memfile_T *, int); -static bhdr_T *mf_alloc_bhdr(memfile_T *, int); -static void mf_free_bhdr(bhdr_T *); -static void mf_ins_free(memfile_T *, bhdr_T *); -static bhdr_T *mf_rem_free(memfile_T *); -static int mf_read(memfile_T *, bhdr_T *); -static int mf_write(memfile_T *, bhdr_T *); -static int mf_write_block(memfile_T *mfp, bhdr_T *hp, off_t offset, - unsigned size); -static int mf_trans_add(memfile_T *, bhdr_T *); -static void mf_do_open(memfile_T *, char_u *, int); -static void mf_hash_init(mf_hashtab_T *); -static void mf_hash_free(mf_hashtab_T *); -static void mf_hash_free_all(mf_hashtab_T *); -static mf_hashitem_T *mf_hash_find(mf_hashtab_T *, blocknr_T); -static void mf_hash_add_item(mf_hashtab_T *, mf_hashitem_T *); -static void mf_hash_rem_item(mf_hashtab_T *, mf_hashitem_T *); -static void mf_hash_grow(mf_hashtab_T *); - -/* - * 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) - */ - -/* - * Open an existing or new memory block file. - * - * fname: name of file to use (NULL means no file at all) - * Note: fname must have been allocated, it is not copied! - * If opening the file fails, fname is freed. - * flags: flags for open() call - * - * If fname != NULL and file cannot be opened, fail. - * - * return value: identifier for this memory block file. - */ -memfile_T *mf_open(char_u *fname, int flags) -{ - memfile_T *mfp; - off_t size; - - if ((mfp = (memfile_T *)alloc((unsigned)sizeof(memfile_T))) == NULL) - return NULL; - - if (fname == NULL) { /* no file for this memfile, use memory only */ - mfp->mf_fname = NULL; - mfp->mf_ffname = NULL; - mfp->mf_fd = -1; - } else { - mf_do_open(mfp, fname, flags); /* try to open the file */ - - /* if the file cannot be opened, return here */ - if (mfp->mf_fd < 0) { - 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; - mfp->mf_old_key = NULL; - - /* - * Try to set the page size equal to the block size of the device. - * Speeds up I/O a lot. - * 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. - */ - FileInfo file_info; - if (mfp->mf_fd >= 0 - && os_get_file_info_fd(mfp->mf_fd, &file_info) - && file_info.stat.st_blksize >= MIN_SWAP_PAGE_SIZE - && file_info.stat.st_blksize <= MAX_SWAP_PAGE_SIZE) { - mfp->mf_page_size = file_info.stat.st_blksize; - } - - if (mfp->mf_fd < 0 || (flags & (O_TRUNC|O_EXCL)) - || (size = lseek(mfp->mf_fd, (off_t)0L, SEEK_END)) <= 0) - mfp->mf_blocknr_max = 0; /* no file or empty file */ - 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 Kbyte): - * '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; - } - mfp->mf_used_count_max = (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. - * If the file already exists, this fails. - * "fname" is the name of file to use (NULL means no file at all) - * Note: "fname" must have been allocated, it is not copied! If opening the - * file fails, "fname" is freed. - * - * return value: FAIL if file could not be opened, OK otherwise - */ -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 delete the associated file if 'del_file' is TRUE. - */ -void mf_close(memfile_T *mfp, int del_file) -{ - bhdr_T *hp, *nextp; - - if (mfp == NULL) /* safety check */ - return; - if (mfp->mf_fd >= 0) { - if (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. - */ -void -mf_close_file ( - buf_T *buf, - int getlines /* get all lines into memory? */ -) -{ - memfile_T *mfp; - linenr_T lnum; - - 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 (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 - * - * negative: TRUE if negative block number desired (data block) - */ -bhdr_T *mf_new(memfile_T *mfp, int negative, int page_count) -{ - bhdr_T *hp; /* new bhdr_T */ - bhdr_T *freep; /* first block in free list */ - char_u *p; - - /* - * 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. - */ - hp = mf_release(mfp, page_count); - - /* - * 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. - */ - freep = mfp->mf_free_first; - 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)) == NULL) - return NULL; - 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 */ - if ((p = (char_u *)alloc(mfp->mf_page_size * page_count)) == NULL) - return NULL; - 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)) == NULL) - return NULL; - 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, - (size_t)mfp->mf_page_size * page_count); - - return hp; -} - -/* - * Get existing block "nr" with "page_count" pages. - * - * Note: The caller should first check a negative nr with mf_trans_del() - */ -bhdr_T *mf_get(memfile_T *mfp, blocknr_T nr, int page_count) -{ - bhdr_T *hp; - /* doesn't exist */ - if (nr >= mfp->mf_blocknr_max || nr <= mfp->mf_blocknr_min) - return NULL; - - /* - * see if it is in the cache - */ - 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)) == NULL) - return NULL; - - 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 - * - * dirty: Block must be written to file later - * infile: Block should be in file (needed for recovery) - * - * no return value, function cannot fail - */ -void mf_put(memfile_T *mfp, bhdr_T *hp, int dirty, int infile) -{ - int flags; - - 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 */ -} - -/* - * block *hp is no longer in used, may put it in the free list of memfile *mfp - */ -void mf_free(memfile_T *mfp, bhdr_T *hp) -{ - free(hp->bh_data); /* free the memory */ - 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 the memory file *mfp to disk. - * 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 for failure, OK otherwise - */ -int mf_sync(memfile_T *mfp, int flags) -{ - int status; - bhdr_T *hp; -#if defined(SYNC_DUP_CLOSE) - int fd; -#endif - 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. - */ - status = OK; - 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 this 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. - */ - if ((fd = dup(mfp->mf_fd)) >= 0) - close(fd); -# endif - } - - got_int |= got_int_save; - - return status; -} - -/* - * For all blocks in memory file *mfp that have a positive block number set - * the dirty flag. 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 *hp in front of hashlist of memfile *mfp - */ -static void mf_ins_hash(memfile_T *mfp, bhdr_T *hp) -{ - mf_hash_add_item(&mfp->mf_hash, (mf_hashitem_T *)hp); -} - -/* - * remove block *hp from hashlist of memfile list *mfp - */ -static void mf_rem_hash(memfile_T *mfp, bhdr_T *hp) -{ - mf_hash_rem_item(&mfp->mf_hash, (mf_hashitem_T *)hp); -} - -/* - * look in hash lists of memfile *mfp for block header with number 'nr' - */ -static bhdr_T *mf_find_hash(memfile_T *mfp, blocknr_T nr) -{ - return (bhdr_T *)mf_hash_find(&mfp->mf_hash, nr); -} - -/* - * insert block *hp in front of used list of memfile *mfp - */ -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 *hp from used list of memfile *mfp - */ -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; -} - -/* - * Release the least recently used block from the used list if the number - * of used memory blocks gets to big. - * - * Return the block header to the caller, including the memory block, so - * it can be re-used. Make sure the page_count is right. - */ -static bhdr_T *mf_release(memfile_T *mfp, int page_count) -{ - bhdr_T *hp; - int need_release; - buf_T *buf; - - /* 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 or total memory used is over 'maxmemtot' - */ - need_release = ((mfp->mf_used_count >= mfp->mf_used_count_max) - || (total_mem_used >> 10) >= (long_u)p_mmt); - - /* - * Try to create a 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 */ - for (buf = firstbuf; buf != NULL; buf = buf->b_next) - if (buf->b_ml.ml_mfp == mfp) - 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; - - 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); - - /* - * If a bhdr_T is returned, make sure that the page_count of bh_data is - * right - */ - if (hp->bh_page_count != page_count) { - free(hp->bh_data); - if ((hp->bh_data = alloc(mfp->mf_page_size * page_count)) == NULL) { - free(hp); - return NULL; - } - 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 - */ -int mf_release_all(void) -{ - buf_T *buf; - memfile_T *mfp; - bhdr_T *hp; - int retval = FALSE; - - for (buf = firstbuf; buf != NULL; buf = buf->b_next) { - 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); - - /* only if there is a swapfile */ - if (mfp->mf_fd >= 0) { - for (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; /* re-start, 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, int page_count) -{ - bhdr_T *hp; - - if ((hp = (bhdr_T *)alloc((unsigned)sizeof(bhdr_T))) != NULL) { - if ((hp->bh_data = (char_u *)alloc(mfp->mf_page_size * page_count)) - == NULL) { - free(hp); /* not enough memory */ - return NULL; - } - hp->bh_page_count = page_count; - } - return hp; -} - -/* - * Free a block header and the block of memory for it - */ -static void mf_free_bhdr(bhdr_T *hp) -{ - free(hp->bh_data); - free(hp); -} - -/* - * insert entry *hp 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 entry from the free list and return a pointer to it - * Note: caller must check that mfp->mf_free_first is not NULL! - */ -static bhdr_T *mf_rem_free(memfile_T *mfp) -{ - bhdr_T *hp; - - hp = mfp->mf_free_first; - mfp->mf_free_first = hp->bh_next; - return hp; -} - -/* - * read a block from disk - * - * Return FAIL for failure, OK otherwise - */ -static int mf_read(memfile_T *mfp, bhdr_T *hp) -{ - off_t offset; - unsigned page_size; - unsigned size; - - if (mfp->mf_fd < 0) /* there is no file, can't read */ - return FAIL; - - page_size = mfp->mf_page_size; - offset = (off_t)page_size * hp->bh_bnum; - 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; - } - - /* Decrypt if 'key' is set and this is a data block. */ - if (*mfp->mf_buffer->b_p_key != NUL) - ml_decrypt_data(mfp, hp->bh_data, offset, size); - - return OK; -} - -/* - * write a block to disk - * - * Return FAIL for failure, OK otherwise - */ -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; - /* appended to the file */ - if (nr + (blocknr_T)page_count > mfp->mf_infile_count) - mfp->mf_infile_count = nr + page_count; - if (nr == hp->bh_bnum) /* written the desired block */ - break; - } - return OK; -} - -/* - * Write block "hp" with data size "size" to file "mfp->mf_fd". - * Takes care of encryption. - * Return FAIL or OK. - */ -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; - - /* Encrypt if 'key' is set and this is a data block. */ - if (*mfp->mf_buffer->b_p_key != NUL) { - data = ml_encrypt_data(mfp, data, offset, size); - } - - if ((unsigned)write_eintr(mfp->mf_fd, data, size) != size) - result = FAIL; - - if (data != hp->bh_data) - free(data); - - return result; -} - -/* - * Make block number for *hp positive and add it to the translation list - * - * Return FAIL for failure, OK otherwise - */ -static int mf_trans_add(memfile_T *mfp, bhdr_T *hp) -{ - bhdr_T *freep; - blocknr_T new_bnum; - NR_TRANS *np; - int page_count; - - if (hp->bh_bnum >= 0) /* it's already positive */ - return OK; - - if ((np = (NR_TRANS *)alloc((unsigned)sizeof(NR_TRANS))) == NULL) - return FAIL; - - /* - * 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. - */ - freep = mfp->mf_free_first; - 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 a translation from the trans lists 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) -{ - NR_TRANS *np; - blocknr_T new_bnum; - - np = (NR_TRANS *)mf_hash_find(&mfp->mf_trans, old_nr); - - if (np == NULL) /* not found */ - return old_nr; - - mfp->mf_neg_count--; - 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 mfp->mf_ffname according to mfp->mf_fname and some other things. - * 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 the name of the file used for the memfile 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 'mfp' - */ -int mf_need_trans(memfile_T *mfp) -{ - return mfp->mf_fname != NULL && mfp->mf_neg_count > 0; -} - -/* - * Open a swap file for a memfile. - * The "fname" must be in allocated memory, and is consumed (also when an - * error occurs). - */ -static void -mf_do_open ( - memfile_T *mfp, - char_u *fname, - int flags /* flags for open() */ -) -{ - mfp->mf_fname = fname; - - /* - * Get the full path name before the open, because this is - * not possible after the open on the Amiga. - * fname cannot be NameBuff, because it must have been allocated. - */ - 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_get_file_info_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 follows. - */ - -/* - * 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) -{ - long_u idx; - mf_hashitem_T *mhi; - mf_hashitem_T *next; - - for (idx = 0; idx <= mht->mht_mask; idx++) - for (mhi = mht->mht_buckets[idx]; mhi != NULL; mhi = next) { - next = mhi->mhi_next; - free(mhi); - } - - mf_hash_free(mht); -} - -/* - * Find "key" in hashtable "mht". - * Returns 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; - - mhi = mht->mht_buckets[key & mht->mht_mask]; - while (mhi != NULL && mhi->mhi_key != key) - mhi = mhi->mhi_next; - - return mhi; -} - -/* - * Add item "mhi" to hashtable "mht". - * "mhi" must not be NULL. - */ -static void mf_hash_add_item(mf_hashtab_T *mht, mf_hashitem_T *mhi) -{ - long_u idx; - - idx = 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 "mhi" from hashtable "mht". - * "mhi" must not be NULL and must have been inserted into "mht". - */ -static void mf_hash_rem_item(mf_hashtab_T *mht, mf_hashitem_T *mhi) -{ - if (mhi->mhi_prev == NULL) - mht->mht_buckets[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) -{ - long_u i, j; - int shift; - mf_hashitem_T *mhi; - mf_hashitem_T *tails[MHT_GROWTH_FACTOR]; - mf_hashitem_T **buckets; - size_t size; - - size = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR * sizeof(void *); - buckets = xcalloc(1, size); - - shift = 0; - while ((mht->mht_mask >> shift) != 0) - shift++; - - for (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 the hashes are computed modulo - * a power of two. - */ - - memset(tails, 0, sizeof(tails)); - - for (mhi = mht->mht_buckets[i]; mhi != NULL; mhi = mhi->mhi_next) { - 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 (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; -} |