diff options
Diffstat (limited to 'src/memfile.c')
| -rw-r--r-- | src/memfile.c | 1500 |
1 files changed, 1500 insertions, 0 deletions
diff --git a/src/memfile.c b/src/memfile.c new file mode 100644 index 0000000..a414d9e --- /dev/null +++ b/src/memfile.c @@ -0,0 +1,1500 @@ +/* vi:set ts=8 sts=4 sw=4 noet: + * + * 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 "vim.h" + +/* + * Some systems have the page size in statfs.f_bsize, some in stat.st_blksize + */ +#ifdef HAVE_ST_BLKSIZE +# define STATFS stat +# define F_BSIZE st_blksize +# define fstatfs(fd, buf, len, nul) mch_fstat((fd), (buf)) +#else +# ifdef HAVE_SYS_STATFS_H +# include <sys/statfs.h> +# define STATFS statfs +# define F_BSIZE f_bsize +# endif +#endif + +/* + * for Amiga Dos 2.0x we use Flush + */ +#ifdef AMIGA +# ifdef FEAT_ARP +extern int dos2; // this is in os_amiga.c +# endif +# ifdef SASC +# include <proto/dos.h> +# include <ios1.h> // for chkufb() +# endif +#endif + +#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 int 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 defined(STATFS) && defined(UNIX) && !defined(__QNX__) && !defined(__minix) +# define USE_FSTATFS + struct STATFS stf; +#endif + + if ((mfp = ALLOC_ONE(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) + { + vim_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; +#ifdef FEAT_CRYPT + mfp->mf_old_key = NULL; +#endif + +#ifdef USE_FSTATFS + /* + * 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. + */ + if (mfp->mf_fd >= 0 + && fstatfs(mfp->mf_fd, &stf, sizeof(struct statfs), 0) == 0 + && stf.F_BSIZE >= MIN_SWAP_PAGE_SIZE + && stf.F_BSIZE <= MAX_SWAP_PAGE_SIZE) + mfp->mf_page_size = stf.F_BSIZE; +#endif + + if (mfp->mf_fd < 0 || (flags & (O_TRUNC|O_EXCL)) + || (size = vim_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 = page_size >> 1; + --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) + mch_remove(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 + vim_free(mf_rem_free(mfp)); + mf_hash_free(&mfp->mf_hash); + mf_hash_free_all(&mfp->mf_trans); // free hashtable and its items + vim_free(mfp->mf_fname); + vim_free(mfp->mf_ffname); + vim_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) + { + mch_remove(mfp->mf_fname); // delete the swap file + VIM_CLEAR(mfp->mf_fname); + VIM_CLEAR(mfp->mf_ffname); + } +} + +/* + * 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 = 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; + vim_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)vim_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) + iemsg(_("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) +{ + vim_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) + { + vim_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; + 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 + /* + * most Unixes have the very useful fsync() function, just what we need. + */ + if (STRCMP(p_sws, "fsync") == 0) + { + if (vim_fsync(mfp->mf_fd)) + status = FAIL; + } + else +# endif + // OpenNT is strictly POSIX (Benzinger) + // Tandem/Himalaya NSK-OSS doesn't have sync() + // No sync() on Stratus VOS +# if defined(__OPENNT) || defined(__TANDEM) || defined(__VOS__) + fflush(NULL); +# else + sync(); +# endif +#endif +#ifdef VMS + if (STRCMP(p_sws, "fsync") == 0) + { + if (vim_fsync(mfp->mf_fd)) + status = FAIL; + } +#endif +#ifdef MSWIN + if (_commit(mfp->mf_fd)) + status = FAIL; +#endif +#ifdef AMIGA +# if defined(__AROS__) || defined(__amigaos4__) + if (vim_fsync(mfp->mf_fd) != 0) + status = FAIL; +# else + /* + * Flush() only exists for AmigaDos 2.0. + * For 1.3 it should be done with close() + open(), but then the risk + * is that the open() may fail and lose the file.... + */ +# ifdef FEAT_ARP + if (dos2) +# endif +# ifdef SASC + { + struct UFB *fp = chkufb(mfp->mf_fd); + + if (fp != NULL) + Flush(fp->ufbfh); + } +# else +# if defined(_DCC) || defined(__GNUC__) || defined(__MORPHOS__) + { +# if defined(__GNUC__) && !defined(__MORPHOS__) && defined(__libnix__) + // Have function (in libnix at least), + // but ain't got no prototype anywhere. + extern unsigned long fdtofh(int filedescriptor); +# endif +# if !defined(__libnix__) + fflush(NULL); +# else + BPTR fh = (BPTR)fdtofh(mfp->mf_fd); + + if (fh != 0) + Flush(fh); +# endif + } +# else // assume Manx + Flush(_devtab[mfp->mf_fd].fd); +# endif +# endif +# endif +#endif // AMIGA + } + + 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. + * + * Returns NULL if no block is released. + */ + 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_ALL_BUFFERS(buf) + 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) + { + vim_free(hp->bh_data); + if ((hp->bh_data = alloc(mfp->mf_page_size * page_count)) == NULL) + { + vim_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_ALL_BUFFERS(buf) + { + 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 = ALLOC_ONE(bhdr_T)) != NULL) + { + if ((hp->bh_data = alloc(mfp->mf_page_size * page_count)) == NULL) + { + vim_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) +{ + vim_free(hp->bh_data); + vim_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 (vim_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; + } + +#ifdef FEAT_CRYPT + // Decrypt if 'key' is set and this is a data block. And when changing the + // key. + if (*mfp->mf_buffer->b_p_key != NUL || mfp->mf_old_key != NULL) + ml_decrypt_data(mfp, hp->bh_data, offset, size); +#endif + + 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 && !mfp->mf_reopen) + // there is no file and there was 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 (;;) + { + int attempt; + + 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 (hp2 == NULL) // freed block, fill with dummy data + page_count = 1; + else + page_count = hp2->bh_page_count; + size = page_size * page_count; + + for (attempt = 1; attempt <= 2; ++attempt) + { + if (mfp->mf_fd >= 0) + { + if (vim_lseek(mfp->mf_fd, offset, SEEK_SET) != offset) + { + PERROR(_("E296: Seek error in swap file write")); + return FAIL; + } + if (mf_write_block(mfp, + hp2 == NULL ? hp : hp2, offset, size) == OK) + break; + } + + if (attempt == 1) + { + // If the swap file is on a network drive, and the network + // gets disconnected and then re-connected, we can maybe fix it + // by closing and then re-opening the file. + if (mfp->mf_fd >= 0) + close(mfp->mf_fd); + mfp->mf_fd = mch_open_rw((char *)mfp->mf_fname, mfp->mf_flags); + mfp->mf_reopen = (mfp->mf_fd < 0); + } + if (attempt == 2 || mfp->mf_fd < 0) + { + // 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 UNUSED, + unsigned size) +{ + char_u *data = hp->bh_data; + int result = OK; + +#ifdef FEAT_CRYPT + // 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 (data == NULL) + return FAIL; + } +#endif + + if ((unsigned)write_eintr(mfp->mf_fd, data, size) != size) + result = FAIL; + +#ifdef FEAT_CRYPT + if (data != hp->bh_data) + vim_free(data); +#endif + + 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 = ALLOC_ONE(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); + vim_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); + + vim_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) + { + vim_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() +{ +#ifdef HAVE_LSTAT + stat_T sb; +#endif + + 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); +#if defined(MSWIN) + /* + * A ":!cd e:xxx" may change the directory without us knowing, use the + * full pathname always. Careful: This frees fname! + */ + mf_fullname(mfp); +#endif + +#ifdef HAVE_LSTAT + /* + * 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. + */ + if ((flags & O_CREAT) && mch_lstat((char *)mfp->mf_fname, &sb) >= 0) + { + mfp->mf_fd = -1; + emsg(_("E300: Swap file already exists (symlink attack?)")); + } + else +#endif + { + /* + * try to open the file + */ + flags |= O_EXTRA | O_NOFOLLOW; +#ifdef MSWIN + // Prevent handle inheritance that cause problems with Cscope + // (swap file may not be deleted if cscope connection was open after + // the file) + flags |= O_NOINHERIT; +#endif + mfp->mf_flags = flags; + 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) + { + VIM_CLEAR(mfp->mf_fname); + VIM_CLEAR(mfp->mf_ffname); + } + else + { +#ifdef HAVE_FD_CLOEXEC + int fdflags = fcntl(mfp->mf_fd, F_GETFD); + if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0) + (void)fcntl(mfp->mf_fd, F_SETFD, fdflags | FD_CLOEXEC); +#endif +#if defined(HAVE_SELINUX) || defined(HAVE_SMACK) + 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) +{ + CLEAR_POINTER(mht); + 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) + vim_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; + vim_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) + { + if (mf_hash_grow(mht) == FAIL) + { + // stop trying to grow after first failure to allocate memory + mht->mht_fixed = 1; + } + } +} + +/* + * 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. + * Returns FAIL when out of memory. + */ + static int +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 = lalloc_clear(size, FALSE); + if (buckets == NULL) + return FAIL; + + 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. + */ + + CLEAR_FIELD(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) + vim_free(mht->mht_buckets); + + mht->mht_buckets = buckets; + mht->mht_mask = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR - 1; + + return OK; +} |