Mercurial > vim
view src/memfile.c @ 32936:c517845bd10e v9.0.1776
patch 9.0.1776: No support for stable Python 3 ABI
Commit: https://github.com/vim/vim/commit/c13b3d1350b60b94fe87f0761ea31c0e7fb6ebf3
Author: Yee Cheng Chin <ychin.git@gmail.com>
Date: Sun Aug 20 21:18:38 2023 +0200
patch 9.0.1776: No support for stable Python 3 ABI
Problem: No support for stable Python 3 ABI
Solution: Support Python 3 stable ABI
Commits:
1) Support Python 3 stable ABI to allow mixed version interoperatbility
Vim currently supports embedding Python for use with plugins, and the
"dynamic" linking option allows the user to specify a locally installed
version of Python by setting `pythonthreedll`. However, one caveat is
that the Python 3 libs are not binary compatible across minor versions,
and mixing versions can potentially be dangerous (e.g. let's say Vim was
linked against the Python 3.10 SDK, but the user sets `pythonthreedll`
to a 3.11 lib). Usually, nothing bad happens, but in theory this could
lead to crashes, memory corruption, and other unpredictable behaviors.
It's also difficult for the user to tell something is wrong because Vim
has no way of reporting what Python 3 version Vim was linked with.
For Vim installed via a package manager, this usually isn't an issue
because all the dependencies would already be figured out. For prebuilt
Vim binaries like MacVim (my motivation for working on this), AppImage,
and Win32 installer this could potentially be an issue as usually a
single binary is distributed. This is more tricky when a new Python
version is released, as there's a chicken-and-egg issue with deciding
what Python version to build against and hard to keep in sync when a new
Python version just drops and we have a mix of users of different Python
versions, and a user just blindly upgrading to a new Python could lead to
bad interactions with Vim.
Python 3 does have a solution for this problem: stable ABI / limited API
(see https://docs.python.org/3/c-api/stable.html). The C SDK limits the
API to a set of functions that are promised to be stable across
versions. This pull request adds an ifdef config that allows us to turn
it on when building Vim. Vim binaries built with this option should be
safe to freely link with any Python 3 libraies without having the
constraint of having to use the same minor version.
Note: Python 2 has no such concept and this doesn't change how Python 2
integration works (not that there is going to be a new version of Python
2 that would cause compatibility issues in the future anyway).
---
Technical details:
======
The stable ABI can be accessed when we compile with the Python 3 limited
API (by defining `Py_LIMITED_API`). The Python 3 code (in `if_python3.c`
and `if_py_both.h`) would now handle this and switch to limited API
mode. Without it set, Vim will still use the full API as before so this
is an opt-in change.
The main difference is that `PyType_Object` is now an opaque struct that
we can't directly create "static types" out of, and we have to create
type objects as "heap types" instead. This is because the struct is not
stable and changes from version to version (e.g. 3.8 added a
`tp_vectorcall` field to it). I had to change all the types to be
allocated on the heap instead with just a pointer to them.
Other functions are also simply missing in limited API, or they are
introduced too late (e.g. `PyUnicode_AsUTF8AndSize` in 3.10) to it that
we need some other ways to do the same thing, so I had to abstract a few
things into macros, and sometimes re-implement functions like
`PyObject_NEW`.
One caveat is that in limited API, `OutputType` (used for replacing
`sys.stdout`) no longer inherits from `PyStdPrinter_Type` which I don't
think has any real issue other than minor differences in how they
convert to a string and missing a couple functions like `mode()` and
`fileno()`.
Also fixed an existing bug where `tp_basicsize` was set incorrectly for
`BufferObject`, `TabListObject, `WinListObject`.
Technically, there could be a small performance drop, there is a little
more indirection with accessing type objects, and some APIs like
`PyUnicode_AsUTF8AndSize` are missing, but in practice I didn't see any
difference, and any well-written Python plugin should try to avoid
excessing callbacks to the `vim` module in Python anyway.
I only tested limited API mode down to Python 3.7, which seemes to
compile and work fine. I haven't tried earlier Python versions.
2) Fix PyIter_Check on older Python vers / type##Ptr unused warning
For PyIter_Check, older versions exposed them as either macros (used in
full API), or a function (for use in limited API). A previous change
exposed PyIter_Check to the dynamic build because Python just moved it
to function-only in 3.10 anyway. Because of that, just make sure we
always grab the function in dynamic builds in earlier versions since
that's what Python eventually did anyway.
3) Move Py_LIMITED_API define to configure script
Can now use --with-python-stable-abi flag to customize what stable ABI
version to target. Can also use an env var to do so as well.
4) Show +python/dyn-stable in :version, and allow has() feature query
Not sure if the "/dyn-stable" suffix would break things, or whether we
should do it another way. Or just don't show it in version and rely on
has() feature checking.
5) Documentation first draft. Still need to implement v:python3_version
6) Fix PyIter_Check build breaks when compiling against Python 3.8
7) Add CI coverage stable ABI on Linux/Windows / make configurable on Windows
This adds configurable options for Windows make files (both MinGW and
MSVC). CI will also now exercise both traditional full API and stable
ABI for Linux and Windows in the matrix for coverage.
Also added a "dynamic" option to Linux matrix as a drive-by change to
make other scripting languages like Ruby / Perl testable under both
static and dynamic builds.
8) Fix inaccuracy in Windows docs
Python's own docs are confusing but you don't actually want to use
`python3.dll` for the dynamic linkage.
9) Add generated autoconf file
10) Add v:python3_version support
This variable indicates the version of Python3 that Vim was built
against (PY_VERSION_HEX), and will be useful to check whether the Python
library you are loading in dynamically actually fits it. When built with
stable ABI, it will be the limited ABI version instead
(`Py_LIMITED_API`), which indicates the minimum version of Python 3 the
user should have, rather than the exact match. When stable ABI is used,
we won't be exposing PY_VERSION_HEX in this var because it just doesn't
seem necessary to do so (the whole point of stable ABI is the promise
that it will work across versions), and I don't want to confuse the user
with too many variables.
Also, cleaned up some documentation, and added help tags.
11) Fix Python 3.7 compat issues
Fix a couple issues when using limited API < 3.8
- Crash on exit: In Python 3.7, if a heap-allocated type is destroyed
before all instances are, it would cause a crash later. This happens
when we destroyed `OptionsType` before calling `Py_Finalize` when
using the limited API. To make it worse, later versions changed the
semantics and now each instance has a strong reference to its own type
and the recommendation has changed to have each instance de-ref its
own type and have its type in GC traversal. To avoid dealing with
these cross-version variations, we just don't free the heap type. They
are static types in non-limited-API anyway and are designed to last
through the entirety of the app, and we also don't restart the Python
runtime and therefore do not need it to have absolutely 0 leaks.
See:
- https://docs.python.org/3/whatsnew/3.8.html#changes-in-the-c-api
- https://docs.python.org/3/whatsnew/3.9.html#changes-in-the-c-api
- PyIter_Check: This function is not provided in limited APIs older than
3.8. Previously I was trying to mock it out using manual
PyType_GetSlot() but it was brittle and also does not actually work
properly for static types (it will generate a Python error). Just
return false. It does mean using limited API < 3.8 is not recommended
as you lose the functionality to handle iterators, but from playing
with plugins I couldn't find it to be an issue.
- Fix loading of PyIter_Check so it will be done when limited API < 3.8.
Otherwise loading a 3.7 Python lib will fail even if limited API was
specified to use it.
12) Make sure to only load `PyUnicode_AsUTF8AndSize` in needed in limited API
We don't use this function unless limited API >= 3.10, but we were
loading it regardless. Usually it's ok in Unix-like systems where Python
just has a single lib that we load from, but in Windows where there is a
separate python3.dll this would not work as the symbol would not have
been exposed in this more limited DLL file. This makes it much clearer
under what condition is this function needed.
closes: #12032
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 | Sun, 20 Aug 2023 21: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; }