Mercurial > vim
view src/memfile.c @ 33521:1f9b1def80c8 v9.0.2009
patch 9.0.2009: cmdline-completion for comma-separated options wrong
Commit: https://github.com/vim/vim/commit/54844857fd6933fa4f6678e47610c4b9c9f7a091
Author: Yee Cheng Chin <ychin.git@gmail.com>
Date: Mon Oct 9 18:12:31 2023 +0200
patch 9.0.2009: cmdline-completion for comma-separated options wrong
Problem: cmdline-completion for comma-separated options wrong
Solution: Fix command-line expansions for options with filenames with
commas
Fix command-line expansions for options with filenames with commas
Cmdline expansion for option values that take a comma-separated list
of file names is currently not handling file names with commas as the
commas are not escaped. For such options, the commas in file names need
to be escaped (to differentiate from a comma that delimit the list
items). The escaped comma is unescaped in `copy_option_part()` during
option parsing.
Fix as follows:
- Cmdline completion for option values with comma-separated file/folder
names will not start a new match when seeing `\\,` and will instead
consider it as one value.
- File/folder regex matching will strip the `\\` when seeing `\\,` to
make sure it can match the correct files/folders.
- The expanded value will escape `,` with `\\,`, similar to how spaces
are escaped to make sure the option value is correct on the cmdline.
This fix also takes into account the fact that Win32 Vim handles file
name escaping differently. Typing '\,' for a file name results in it
being handled literally but in other platforms '\,' is interpreted as a
simple ',' and commas need to be escaped using '\\,' instead.
Also, make sure this new logic only applies to comma-separated options
like 'path'. Non-list options like 'set makeprg=<Tab>' and regular ex
commands like `:edit <Tab>` do not require escaping and will continue to
work.
Also fix up documentation to be clearer. The original docs are slightly
misleading in how it discusses triple slashes for 'tags'.
closes: #13303
related: #13301
Signed-off-by: Christian Brabandt <cb@256bit.org>
Co-authored-by: Yee Cheng Chin <ychin.git@gmail.com>
author | Christian Brabandt <cb@256bit.org> |
---|---|
date | Mon, 09 Oct 2023 18:30:04 +0200 |
parents | 695b50472e85 |
children |
line wrap: on
line source
/* 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 <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 = MF_DIRTY_NO; 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 = MF_DIRTY_YES; 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_close_error_on_swap_file)); } 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 -= (long_u)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_close_error_on_swap_file)); 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((size_t)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 = MF_DIRTY_YES; 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 && page_count > 0) hp = mf_alloc_bhdr(mfp, page_count); if (hp == 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(e_block_was_not_locked); flags &= ~BH_LOCKED; if (dirty) { flags |= BH_DIRTY; if (mfp->mf_dirty != MF_DIRTY_YES_NOSYNC) mfp->mf_dirty = MF_DIRTY_YES; } 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 = MF_DIRTY_NO; 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 = MF_DIRTY_NO; 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 = MF_DIRTY_YES; } /* * 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 += (long_u)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 -= (long_u)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_CLEAR(hp->bh_data); if (page_count > 0) hp->bh_data = alloc((size_t)mfp->mf_page_size * page_count); if (hp->bh_data == 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) return NULL; if ((hp->bh_data = alloc((size_t)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(_(e_seek_error_in_swap_file_read)); return FAIL; } if ((unsigned)read_eintr(mfp->mf_fd, hp->bh_data, size) != size) { PERROR(_(e_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(_(e_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(_(e_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) return; 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(_(e_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; }