Mercurial > vim
annotate src/memfile.c @ 16823:b1b7c7a31679 v8.1.1413
patch 8.1.1413: error when the drive of the swap file was disconnected
commit https://github.com/vim/vim/commit/b58a4b938c4bc7e0499700859bd7abba9acc5b11
Author: Bram Moolenaar <Bram@vim.org>
Date: Mon May 27 23:36:21 2019 +0200
patch 8.1.1413: error when the drive of the swap file was disconnected
Problem: Error when the drive of the swap file was disconnected.
Solution: Try closing and re-opening the swap file. (closes https://github.com/vim/vim/issues/4378)
author | Bram Moolenaar <Bram@vim.org> |
---|---|
date | Mon, 27 May 2019 23:45:04 +0200 |
parents | ef00b6bc186b |
children | ce04ebdf26b8 |
rev | line source |
---|---|
10042
4aead6a9b7a9
commit https://github.com/vim/vim/commit/edf3f97ae2af024708ebb4ac614227327033ca47
Christian Brabandt <cb@256bit.org>
parents:
9649
diff
changeset
|
1 /* vi:set ts=8 sts=4 sw=4 noet: |
7 | 2 * |
3 * VIM - Vi IMproved by Bram Moolenaar | |
4 * | |
5 * Do ":help uganda" in Vim to read copying and usage conditions. | |
6 * Do ":help credits" in Vim to see a list of people who contributed. | |
7 * See README.txt for an overview of the Vim source code. | |
8 */ | |
9 | |
10 /* | |
11 * memfile.c: Contains the functions for handling blocks of memory which can | |
12 * be stored in a file. This is the implementation of a sort of virtual memory. | |
13 * | |
14 * A memfile consists of a sequence of blocks. The blocks numbered from 0 | |
15 * upwards have been assigned a place in the actual file. The block number | |
16 * is equal to the page number in the file. The | |
17 * blocks with negative numbers are currently in memory only. They can be | |
18 * assigned a place in the file when too much memory is being used. At that | |
19 * moment they get a new, positive, number. A list is used for translation of | |
20 * negative to positive numbers. | |
21 * | |
22 * The size of a block is a multiple of a page size, normally the page size of | |
23 * the device the file is on. Most blocks are 1 page long. A Block of multiple | |
24 * pages is used for a line that does not fit in a single page. | |
25 * | |
26 * Each block can be in memory and/or in a file. The block stays in memory | |
27 * as long as it is locked. If it is no longer locked it can be swapped out to | |
28 * the file. It is only written to the file if it has been changed. | |
29 * | |
30 * Under normal operation the file is created when opening the memory file and | |
31 * deleted when closing the memory file. Only with recovery an existing memory | |
32 * file is opened. | |
33 */ | |
34 | |
35 #include "vim.h" | |
36 | |
37 /* | |
38 * Some systems have the page size in statfs.f_bsize, some in stat.st_blksize | |
39 */ | |
40 #ifdef HAVE_ST_BLKSIZE | |
41 # define STATFS stat | |
42 # define F_BSIZE st_blksize | |
43 # define fstatfs(fd, buf, len, nul) mch_fstat((fd), (buf)) | |
44 #else | |
45 # ifdef HAVE_SYS_STATFS_H | |
46 # include <sys/statfs.h> | |
47 # define STATFS statfs | |
48 # define F_BSIZE f_bsize | |
49 # ifdef __MINT__ /* do we still need this? */ | |
50 # define fstatfs(fd, buf, len, nul) mch_fstat((fd), (buf)) | |
51 # endif | |
52 # endif | |
53 #endif | |
54 | |
55 /* | |
56 * for Amiga Dos 2.0x we use Flush | |
57 */ | |
58 #ifdef AMIGA | |
59 # ifdef FEAT_ARP | |
60 extern int dos2; /* this is in os_amiga.c */ | |
61 # endif | |
62 # ifdef SASC | |
63 # include <proto/dos.h> | |
64 # include <ios1.h> /* for chkufb() */ | |
65 # endif | |
66 #endif | |
67 | |
68 #define MEMFILE_PAGE_SIZE 4096 /* default page size */ | |
69 | |
70 static long_u total_mem_used = 0; /* total memory used for memfiles */ | |
71 | |
7803
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
72 static void mf_ins_hash(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
73 static void mf_rem_hash(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
74 static bhdr_T *mf_find_hash(memfile_T *, blocknr_T); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
75 static void mf_ins_used(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
76 static void mf_rem_used(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
77 static bhdr_T *mf_release(memfile_T *, int); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
78 static bhdr_T *mf_alloc_bhdr(memfile_T *, int); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
79 static void mf_free_bhdr(bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
80 static void mf_ins_free(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
81 static bhdr_T *mf_rem_free(memfile_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
82 static int mf_read(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
83 static int mf_write(memfile_T *, bhdr_T *); |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
84 static int mf_write_block(memfile_T *mfp, bhdr_T *hp, off_T offset, unsigned size); |
7803
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
85 static int mf_trans_add(memfile_T *, bhdr_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
86 static void mf_do_open(memfile_T *, char_u *, int); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
87 static void mf_hash_init(mf_hashtab_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
88 static void mf_hash_free(mf_hashtab_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
89 static void mf_hash_free_all(mf_hashtab_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
90 static mf_hashitem_T *mf_hash_find(mf_hashtab_T *, blocknr_T); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
91 static void mf_hash_add_item(mf_hashtab_T *, mf_hashitem_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
92 static void mf_hash_rem_item(mf_hashtab_T *, mf_hashitem_T *); |
37c929c4a073
commit https://github.com/vim/vim/commit/92b8b2d307e34117f146319872010b0ccc9d2713
Christian Brabandt <cb@256bit.org>
parents:
7347
diff
changeset
|
93 static int mf_hash_grow(mf_hashtab_T *); |
7 | 94 |
95 /* | |
96 * The functions for using a memfile: | |
97 * | |
98 * mf_open() open a new or existing memfile | |
99 * mf_open_file() open a swap file for an existing memfile | |
100 * mf_close() close (and delete) a memfile | |
101 * mf_new() create a new block in a memfile and lock it | |
102 * mf_get() get an existing block and lock it | |
103 * mf_put() unlock a block, may be marked for writing | |
104 * mf_free() remove a block | |
105 * mf_sync() sync changed parts of memfile to disk | |
106 * mf_release_all() release as much memory as possible | |
107 * mf_trans_del() may translate negative to positive block number | |
108 * mf_fullname() make file name full path (use before first :cd) | |
109 */ | |
110 | |
111 /* | |
112 * Open an existing or new memory block file. | |
113 * | |
114 * fname: name of file to use (NULL means no file at all) | |
115 * Note: fname must have been allocated, it is not copied! | |
116 * If opening the file fails, fname is freed. | |
117 * flags: flags for open() call | |
118 * | |
119 * If fname != NULL and file cannot be opened, fail. | |
120 * | |
121 * return value: identifier for this memory block file. | |
122 */ | |
123 memfile_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
124 mf_open(char_u *fname, int flags) |
7 | 125 { |
126 memfile_T *mfp; | |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
127 off_T size; |
4519
fba9c0f86f77
updated for version 7.3.1007
Bram Moolenaar <bram@vim.org>
parents:
4352
diff
changeset
|
128 #if defined(STATFS) && defined(UNIX) && !defined(__QNX__) && !defined(__minix) |
7 | 129 # define USE_FSTATFS |
130 struct STATFS stf; | |
131 #endif | |
132 | |
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
133 if ((mfp = (memfile_T *)alloc(sizeof(memfile_T))) == NULL) |
7 | 134 return NULL; |
135 | |
136 if (fname == NULL) /* no file for this memfile, use memory only */ | |
137 { | |
138 mfp->mf_fname = NULL; | |
139 mfp->mf_ffname = NULL; | |
140 mfp->mf_fd = -1; | |
141 } | |
142 else | |
143 { | |
144 mf_do_open(mfp, fname, flags); /* try to open the file */ | |
145 | |
146 /* if the file cannot be opened, return here */ | |
147 if (mfp->mf_fd < 0) | |
148 { | |
149 vim_free(mfp); | |
150 return NULL; | |
151 } | |
152 } | |
153 | |
154 mfp->mf_free_first = NULL; /* free list is empty */ | |
155 mfp->mf_used_first = NULL; /* used list is empty */ | |
156 mfp->mf_used_last = NULL; | |
157 mfp->mf_dirty = FALSE; | |
158 mfp->mf_used_count = 0; | |
2730 | 159 mf_hash_init(&mfp->mf_hash); |
160 mf_hash_init(&mfp->mf_trans); | |
7 | 161 mfp->mf_page_size = MEMFILE_PAGE_SIZE; |
2267 | 162 #ifdef FEAT_CRYPT |
163 mfp->mf_old_key = NULL; | |
164 #endif | |
7 | 165 |
166 #ifdef USE_FSTATFS | |
167 /* | |
168 * Try to set the page size equal to the block size of the device. | |
169 * Speeds up I/O a lot. | |
170 * When recovering, the actual block size will be retrieved from block 0 | |
171 * in ml_recover(). The size used here may be wrong, therefore | |
172 * mf_blocknr_max must be rounded up. | |
173 */ | |
174 if (mfp->mf_fd >= 0 | |
175 && fstatfs(mfp->mf_fd, &stf, sizeof(struct statfs), 0) == 0 | |
176 && stf.F_BSIZE >= MIN_SWAP_PAGE_SIZE | |
177 && stf.F_BSIZE <= MAX_SWAP_PAGE_SIZE) | |
178 mfp->mf_page_size = stf.F_BSIZE; | |
179 #endif | |
180 | |
181 if (mfp->mf_fd < 0 || (flags & (O_TRUNC|O_EXCL)) | |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
182 || (size = vim_lseek(mfp->mf_fd, (off_T)0L, SEEK_END)) <= 0) |
7 | 183 mfp->mf_blocknr_max = 0; /* no file or empty file */ |
184 else | |
185 mfp->mf_blocknr_max = (blocknr_T)((size + mfp->mf_page_size - 1) | |
186 / mfp->mf_page_size); | |
187 mfp->mf_blocknr_min = -1; | |
188 mfp->mf_neg_count = 0; | |
189 mfp->mf_infile_count = mfp->mf_blocknr_max; | |
1230 | 190 |
191 /* | |
192 * Compute maximum number of pages ('maxmem' is in Kbyte): | |
193 * 'mammem' * 1Kbyte / page-size-in-bytes. | |
194 * Avoid overflow by first reducing page size as much as possible. | |
195 */ | |
196 { | |
197 int shift = 10; | |
198 unsigned page_size = mfp->mf_page_size; | |
199 | |
200 while (shift > 0 && (page_size & 1) == 0) | |
201 { | |
202 page_size = page_size >> 1; | |
203 --shift; | |
204 } | |
205 mfp->mf_used_count_max = (p_mm << shift) / page_size; | |
206 if (mfp->mf_used_count_max < 10) | |
207 mfp->mf_used_count_max = 10; | |
208 } | |
7 | 209 |
210 return mfp; | |
211 } | |
212 | |
213 /* | |
214 * Open a file for an existing memfile. Used when updatecount set from 0 to | |
215 * some value. | |
216 * If the file already exists, this fails. | |
217 * "fname" is the name of file to use (NULL means no file at all) | |
218 * Note: "fname" must have been allocated, it is not copied! If opening the | |
219 * file fails, "fname" is freed. | |
220 * | |
221 * return value: FAIL if file could not be opened, OK otherwise | |
222 */ | |
223 int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
224 mf_open_file(memfile_T *mfp, char_u *fname) |
7 | 225 { |
226 mf_do_open(mfp, fname, O_RDWR|O_CREAT|O_EXCL); /* try to open the file */ | |
227 | |
228 if (mfp->mf_fd < 0) | |
229 return FAIL; | |
230 | |
231 mfp->mf_dirty = TRUE; | |
232 return OK; | |
233 } | |
234 | |
235 /* | |
2249
6d3d35ff2c2b
Use full path in undofile(). Updated docs.
Bram Moolenaar <bram@vim.org>
parents:
2003
diff
changeset
|
236 * Close a memory file and delete the associated file if 'del_file' is TRUE. |
7 | 237 */ |
238 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
239 mf_close(memfile_T *mfp, int del_file) |
7 | 240 { |
241 bhdr_T *hp, *nextp; | |
242 | |
243 if (mfp == NULL) /* safety check */ | |
244 return; | |
245 if (mfp->mf_fd >= 0) | |
246 { | |
247 if (close(mfp->mf_fd) < 0) | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
14822
diff
changeset
|
248 emsg(_(e_swapclose)); |
7 | 249 } |
250 if (del_file && mfp->mf_fname != NULL) | |
251 mch_remove(mfp->mf_fname); | |
252 /* free entries in used list */ | |
253 for (hp = mfp->mf_used_first; hp != NULL; hp = nextp) | |
254 { | |
255 total_mem_used -= hp->bh_page_count * mfp->mf_page_size; | |
256 nextp = hp->bh_next; | |
257 mf_free_bhdr(hp); | |
258 } | |
259 while (mfp->mf_free_first != NULL) /* free entries in free list */ | |
260 vim_free(mf_rem_free(mfp)); | |
2730 | 261 mf_hash_free(&mfp->mf_hash); |
262 mf_hash_free_all(&mfp->mf_trans); /* free hashtable and its items */ | |
7 | 263 vim_free(mfp->mf_fname); |
264 vim_free(mfp->mf_ffname); | |
265 vim_free(mfp); | |
266 } | |
267 | |
268 /* | |
269 * Close the swap file for a memfile. Used when 'swapfile' is reset. | |
270 */ | |
271 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
272 mf_close_file( |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
273 buf_T *buf, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
274 int getlines) /* get all lines into memory? */ |
7 | 275 { |
276 memfile_T *mfp; | |
277 linenr_T lnum; | |
278 | |
279 mfp = buf->b_ml.ml_mfp; | |
280 if (mfp == NULL || mfp->mf_fd < 0) /* nothing to close */ | |
281 return; | |
282 | |
283 if (getlines) | |
284 { | |
285 /* get all blocks in memory by accessing all lines (clumsy!) */ | |
1066 | 286 mf_dont_release = TRUE; |
7 | 287 for (lnum = 1; lnum <= buf->b_ml.ml_line_count; ++lnum) |
288 (void)ml_get_buf(buf, lnum, FALSE); | |
1066 | 289 mf_dont_release = FALSE; |
7 | 290 /* TODO: should check if all blocks are really in core */ |
291 } | |
292 | |
293 if (close(mfp->mf_fd) < 0) /* close the file */ | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
14822
diff
changeset
|
294 emsg(_(e_swapclose)); |
7 | 295 mfp->mf_fd = -1; |
296 | |
297 if (mfp->mf_fname != NULL) | |
298 { | |
299 mch_remove(mfp->mf_fname); /* delete the swap file */ | |
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
300 VIM_CLEAR(mfp->mf_fname); |
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
301 VIM_CLEAR(mfp->mf_ffname); |
7 | 302 } |
303 } | |
304 | |
305 /* | |
306 * Set new size for a memfile. Used when block 0 of a swapfile has been read | |
307 * and the size it indicates differs from what was guessed. | |
308 */ | |
309 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
310 mf_new_page_size(memfile_T *mfp, unsigned new_size) |
7 | 311 { |
312 /* Correct the memory used for block 0 to the new size, because it will be | |
313 * freed with that size later on. */ | |
314 total_mem_used += new_size - mfp->mf_page_size; | |
315 mfp->mf_page_size = new_size; | |
316 } | |
317 | |
318 /* | |
319 * get a new block | |
320 * | |
321 * negative: TRUE if negative block number desired (data block) | |
322 */ | |
323 bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
324 mf_new(memfile_T *mfp, int negative, int page_count) |
7 | 325 { |
1166 | 326 bhdr_T *hp; /* new bhdr_T */ |
327 bhdr_T *freep; /* first block in free list */ | |
328 char_u *p; | |
7 | 329 |
330 /* | |
331 * If we reached the maximum size for the used memory blocks, release one | |
332 * If a bhdr_T is returned, use it and adjust the page_count if necessary. | |
333 */ | |
334 hp = mf_release(mfp, page_count); | |
335 | |
336 /* | |
337 * Decide on the number to use: | |
338 * If there is a free block, use its number. | |
339 * Otherwise use mf_block_min for a negative number, mf_block_max for | |
340 * a positive number. | |
341 */ | |
342 freep = mfp->mf_free_first; | |
343 if (!negative && freep != NULL && freep->bh_page_count >= page_count) | |
344 { | |
345 /* | |
346 * If the block in the free list has more pages, take only the number | |
347 * of pages needed and allocate a new bhdr_T with data | |
348 * | |
1166 | 349 * If the number of pages matches and mf_release() did not return a |
350 * bhdr_T, use the bhdr_T from the free list and allocate the data | |
7 | 351 * |
1166 | 352 * If the number of pages matches and mf_release() returned a bhdr_T, |
7 | 353 * just use the number and free the bhdr_T from the free list |
354 */ | |
355 if (freep->bh_page_count > page_count) | |
356 { | |
357 if (hp == NULL && (hp = mf_alloc_bhdr(mfp, page_count)) == NULL) | |
358 return NULL; | |
359 hp->bh_bnum = freep->bh_bnum; | |
360 freep->bh_bnum += page_count; | |
361 freep->bh_page_count -= page_count; | |
362 } | |
363 else if (hp == NULL) /* need to allocate memory for this block */ | |
364 { | |
365 if ((p = (char_u *)alloc(mfp->mf_page_size * page_count)) == NULL) | |
366 return NULL; | |
367 hp = mf_rem_free(mfp); | |
368 hp->bh_data = p; | |
369 } | |
370 else /* use the number, remove entry from free list */ | |
371 { | |
372 freep = mf_rem_free(mfp); | |
373 hp->bh_bnum = freep->bh_bnum; | |
374 vim_free(freep); | |
375 } | |
376 } | |
377 else /* get a new number */ | |
378 { | |
379 if (hp == NULL && (hp = mf_alloc_bhdr(mfp, page_count)) == NULL) | |
380 return NULL; | |
381 if (negative) | |
382 { | |
383 hp->bh_bnum = mfp->mf_blocknr_min--; | |
384 mfp->mf_neg_count++; | |
385 } | |
386 else | |
387 { | |
388 hp->bh_bnum = mfp->mf_blocknr_max; | |
389 mfp->mf_blocknr_max += page_count; | |
390 } | |
391 } | |
392 hp->bh_flags = BH_LOCKED | BH_DIRTY; /* new block is always dirty */ | |
393 mfp->mf_dirty = TRUE; | |
394 hp->bh_page_count = page_count; | |
395 mf_ins_used(mfp, hp); | |
396 mf_ins_hash(mfp, hp); | |
397 | |
398 /* | |
399 * Init the data to all zero, to avoid reading uninitialized data. | |
400 * This also avoids that the passwd file ends up in the swap file! | |
401 */ | |
2249
6d3d35ff2c2b
Use full path in undofile(). Updated docs.
Bram Moolenaar <bram@vim.org>
parents:
2003
diff
changeset
|
402 (void)vim_memset((char *)(hp->bh_data), 0, |
6d3d35ff2c2b
Use full path in undofile(). Updated docs.
Bram Moolenaar <bram@vim.org>
parents:
2003
diff
changeset
|
403 (size_t)mfp->mf_page_size * page_count); |
7 | 404 |
405 return hp; | |
406 } | |
407 | |
408 /* | |
2267 | 409 * Get existing block "nr" with "page_count" pages. |
7 | 410 * |
411 * Note: The caller should first check a negative nr with mf_trans_del() | |
412 */ | |
413 bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
414 mf_get(memfile_T *mfp, blocknr_T nr, int page_count) |
7 | 415 { |
416 bhdr_T *hp; | |
417 /* doesn't exist */ | |
418 if (nr >= mfp->mf_blocknr_max || nr <= mfp->mf_blocknr_min) | |
419 return NULL; | |
420 | |
421 /* | |
422 * see if it is in the cache | |
423 */ | |
424 hp = mf_find_hash(mfp, nr); | |
425 if (hp == NULL) /* not in the hash list */ | |
426 { | |
427 if (nr < 0 || nr >= mfp->mf_infile_count) /* can't be in the file */ | |
428 return NULL; | |
429 | |
430 /* could check here if the block is in the free list */ | |
431 | |
432 /* | |
433 * Check if we need to flush an existing block. | |
434 * If so, use that block. | |
435 * If not, allocate a new block. | |
436 */ | |
437 hp = mf_release(mfp, page_count); | |
438 if (hp == NULL && (hp = mf_alloc_bhdr(mfp, page_count)) == NULL) | |
439 return NULL; | |
440 | |
441 hp->bh_bnum = nr; | |
442 hp->bh_flags = 0; | |
443 hp->bh_page_count = page_count; | |
444 if (mf_read(mfp, hp) == FAIL) /* cannot read the block! */ | |
445 { | |
446 mf_free_bhdr(hp); | |
447 return NULL; | |
448 } | |
449 } | |
450 else | |
451 { | |
452 mf_rem_used(mfp, hp); /* remove from list, insert in front below */ | |
453 mf_rem_hash(mfp, hp); | |
454 } | |
455 | |
456 hp->bh_flags |= BH_LOCKED; | |
457 mf_ins_used(mfp, hp); /* put in front of used list */ | |
458 mf_ins_hash(mfp, hp); /* put in front of hash list */ | |
459 | |
460 return hp; | |
461 } | |
462 | |
463 /* | |
464 * release the block *hp | |
465 * | |
466 * dirty: Block must be written to file later | |
467 * infile: Block should be in file (needed for recovery) | |
468 * | |
469 * no return value, function cannot fail | |
470 */ | |
471 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
472 mf_put( |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
473 memfile_T *mfp, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
474 bhdr_T *hp, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
475 int dirty, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
476 int infile) |
7 | 477 { |
478 int flags; | |
479 | |
480 flags = hp->bh_flags; | |
481 | |
482 if ((flags & BH_LOCKED) == 0) | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
14822
diff
changeset
|
483 iemsg(_("E293: block was not locked")); |
7 | 484 flags &= ~BH_LOCKED; |
485 if (dirty) | |
486 { | |
487 flags |= BH_DIRTY; | |
488 mfp->mf_dirty = TRUE; | |
489 } | |
490 hp->bh_flags = flags; | |
491 if (infile) | |
492 mf_trans_add(mfp, hp); /* may translate negative in positive nr */ | |
493 } | |
494 | |
495 /* | |
496 * block *hp is no longer in used, may put it in the free list of memfile *mfp | |
497 */ | |
498 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
499 mf_free(memfile_T *mfp, bhdr_T *hp) |
7 | 500 { |
501 vim_free(hp->bh_data); /* free the memory */ | |
502 mf_rem_hash(mfp, hp); /* get *hp out of the hash list */ | |
503 mf_rem_used(mfp, hp); /* get *hp out of the used list */ | |
504 if (hp->bh_bnum < 0) | |
505 { | |
506 vim_free(hp); /* don't want negative numbers in free list */ | |
507 mfp->mf_neg_count--; | |
508 } | |
509 else | |
510 mf_ins_free(mfp, hp); /* put *hp in the free list */ | |
511 } | |
512 | |
984 | 513 #if defined(__MORPHOS__) && defined(__libnix__) |
7 | 514 /* function is missing in MorphOS libnix version */ |
515 extern unsigned long *__stdfiledes; | |
516 | |
517 static unsigned long | |
518 fdtofh(int filedescriptor) | |
519 { | |
520 return __stdfiledes[filedescriptor]; | |
521 } | |
522 #endif | |
523 | |
524 /* | |
525 * Sync the memory file *mfp to disk. | |
526 * Flags: | |
527 * MFS_ALL If not given, blocks with negative numbers are not synced, | |
528 * even when they are dirty! | |
529 * MFS_STOP Stop syncing when a character becomes available, but sync at | |
530 * least one block. | |
531 * MFS_FLUSH Make sure buffers are flushed to disk, so they will survive a | |
532 * system crash. | |
533 * MFS_ZERO Only write block 0. | |
534 * | |
535 * Return FAIL for failure, OK otherwise | |
536 */ | |
537 int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
538 mf_sync(memfile_T *mfp, int flags) |
7 | 539 { |
540 int status; | |
541 bhdr_T *hp; | |
542 int got_int_save = got_int; | |
543 | |
544 if (mfp->mf_fd < 0) /* there is no file, nothing to do */ | |
545 { | |
546 mfp->mf_dirty = FALSE; | |
547 return FAIL; | |
548 } | |
549 | |
550 /* Only a CTRL-C while writing will break us here, not one typed | |
551 * previously. */ | |
552 got_int = FALSE; | |
553 | |
554 /* | |
555 * sync from last to first (may reduce the probability of an inconsistent | |
556 * file) If a write fails, it is very likely caused by a full filesystem. | |
557 * Then we only try to write blocks within the existing file. If that also | |
558 * fails then we give up. | |
559 */ | |
560 status = OK; | |
561 for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev) | |
562 if (((flags & MFS_ALL) || hp->bh_bnum >= 0) | |
563 && (hp->bh_flags & BH_DIRTY) | |
564 && (status == OK || (hp->bh_bnum >= 0 | |
565 && hp->bh_bnum < mfp->mf_infile_count))) | |
566 { | |
567 if ((flags & MFS_ZERO) && hp->bh_bnum != 0) | |
568 continue; | |
569 if (mf_write(mfp, hp) == FAIL) | |
570 { | |
571 if (status == FAIL) /* double error: quit syncing */ | |
572 break; | |
573 status = FAIL; | |
574 } | |
575 if (flags & MFS_STOP) | |
576 { | |
577 /* Stop when char available now. */ | |
578 if (ui_char_avail()) | |
579 break; | |
580 } | |
581 else | |
582 ui_breakcheck(); | |
583 if (got_int) | |
584 break; | |
585 } | |
586 | |
587 /* | |
588 * If the whole list is flushed, the memfile is not dirty anymore. | |
589 * In case of an error this flag is also set, to avoid trying all the time. | |
590 */ | |
591 if (hp == NULL || status == FAIL) | |
592 mfp->mf_dirty = FALSE; | |
593 | |
594 if ((flags & MFS_FLUSH) && *p_sws != NUL) | |
595 { | |
596 #if defined(UNIX) | |
597 # ifdef HAVE_FSYNC | |
598 /* | |
599 * most Unixes have the very useful fsync() function, just what we need. | |
600 */ | |
601 if (STRCMP(p_sws, "fsync") == 0) | |
602 { | |
15816
40336d427dd2
patch 8.1.0915: fsync() may not work properly on Mac
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
603 if (vim_fsync(mfp->mf_fd)) |
7 | 604 status = FAIL; |
605 } | |
606 else | |
607 # endif | |
608 /* OpenNT is strictly POSIX (Benzinger) */ | |
609 /* Tandem/Himalaya NSK-OSS doesn't have sync() */ | |
6637 | 610 /* No sync() on Stratus VOS */ |
611 # if defined(__OPENNT) || defined(__TANDEM) || defined(__VOS__) | |
7 | 612 fflush(NULL); |
613 # else | |
614 sync(); | |
615 # endif | |
616 #endif | |
617 #ifdef VMS | |
618 if (STRCMP(p_sws, "fsync") == 0) | |
619 { | |
15816
40336d427dd2
patch 8.1.0915: fsync() may not work properly on Mac
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
620 if (vim_fsync(mfp->mf_fd)) |
7 | 621 status = FAIL; |
622 } | |
623 #endif | |
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15816
diff
changeset
|
624 #ifdef MSWIN |
14822
aa9c7588d30a
patch 8.1.0423: MS-Windows: using dup-close for flushing a file
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
625 if (_commit(mfp->mf_fd)) |
aa9c7588d30a
patch 8.1.0423: MS-Windows: using dup-close for flushing a file
Christian Brabandt <cb@256bit.org>
parents:
13244
diff
changeset
|
626 status = FAIL; |
7 | 627 #endif |
628 #ifdef AMIGA | |
1030 | 629 # if defined(__AROS__) || defined(__amigaos4__) |
15816
40336d427dd2
patch 8.1.0915: fsync() may not work properly on Mac
Bram Moolenaar <Bram@vim.org>
parents:
15470
diff
changeset
|
630 if (vim_fsync(mfp->mf_fd) != 0) |
7 | 631 status = FAIL; |
632 # else | |
633 /* | |
634 * Flush() only exists for AmigaDos 2.0. | |
635 * For 1.3 it should be done with close() + open(), but then the risk | |
636 * is that the open() may fail and lose the file.... | |
637 */ | |
638 # ifdef FEAT_ARP | |
639 if (dos2) | |
640 # endif | |
641 # ifdef SASC | |
642 { | |
643 struct UFB *fp = chkufb(mfp->mf_fd); | |
644 | |
645 if (fp != NULL) | |
646 Flush(fp->ufbfh); | |
647 } | |
648 # else | |
649 # if defined(_DCC) || defined(__GNUC__) || defined(__MORPHOS__) | |
650 { | |
984 | 651 # if defined(__GNUC__) && !defined(__MORPHOS__) && defined(__libnix__) |
7 | 652 /* Have function (in libnix at least), |
653 * but ain't got no prototype anywhere. */ | |
654 extern unsigned long fdtofh(int filedescriptor); | |
655 # endif | |
984 | 656 # if !defined(__libnix__) |
657 fflush(NULL); | |
658 # else | |
7 | 659 BPTR fh = (BPTR)fdtofh(mfp->mf_fd); |
660 | |
661 if (fh != 0) | |
662 Flush(fh); | |
984 | 663 # endif |
7 | 664 } |
665 # else /* assume Manx */ | |
666 Flush(_devtab[mfp->mf_fd].fd); | |
667 # endif | |
668 # endif | |
669 # endif | |
670 #endif /* AMIGA */ | |
671 } | |
672 | |
673 got_int |= got_int_save; | |
674 | |
675 return status; | |
676 } | |
677 | |
678 /* | |
630 | 679 * For all blocks in memory file *mfp that have a positive block number set |
680 * the dirty flag. These are blocks that need to be written to a newly | |
681 * created swapfile. | |
682 */ | |
683 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
684 mf_set_dirty(memfile_T *mfp) |
630 | 685 { |
686 bhdr_T *hp; | |
687 | |
688 for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev) | |
689 if (hp->bh_bnum > 0) | |
690 hp->bh_flags |= BH_DIRTY; | |
691 mfp->mf_dirty = TRUE; | |
692 } | |
693 | |
694 /* | |
7 | 695 * insert block *hp in front of hashlist of memfile *mfp |
696 */ | |
697 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
698 mf_ins_hash(memfile_T *mfp, bhdr_T *hp) |
7 | 699 { |
2730 | 700 mf_hash_add_item(&mfp->mf_hash, (mf_hashitem_T *)hp); |
7 | 701 } |
702 | |
703 /* | |
704 * remove block *hp from hashlist of memfile list *mfp | |
705 */ | |
706 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
707 mf_rem_hash(memfile_T *mfp, bhdr_T *hp) |
7 | 708 { |
2730 | 709 mf_hash_rem_item(&mfp->mf_hash, (mf_hashitem_T *)hp); |
7 | 710 } |
711 | |
712 /* | |
713 * look in hash lists of memfile *mfp for block header with number 'nr' | |
714 */ | |
715 static bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
716 mf_find_hash(memfile_T *mfp, blocknr_T nr) |
7 | 717 { |
2730 | 718 return (bhdr_T *)mf_hash_find(&mfp->mf_hash, nr); |
7 | 719 } |
720 | |
721 /* | |
722 * insert block *hp in front of used list of memfile *mfp | |
723 */ | |
724 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
725 mf_ins_used(memfile_T *mfp, bhdr_T *hp) |
7 | 726 { |
727 hp->bh_next = mfp->mf_used_first; | |
728 mfp->mf_used_first = hp; | |
729 hp->bh_prev = NULL; | |
730 if (hp->bh_next == NULL) /* list was empty, adjust last pointer */ | |
731 mfp->mf_used_last = hp; | |
732 else | |
733 hp->bh_next->bh_prev = hp; | |
734 mfp->mf_used_count += hp->bh_page_count; | |
735 total_mem_used += hp->bh_page_count * mfp->mf_page_size; | |
736 } | |
737 | |
738 /* | |
739 * remove block *hp from used list of memfile *mfp | |
740 */ | |
741 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
742 mf_rem_used(memfile_T *mfp, bhdr_T *hp) |
7 | 743 { |
744 if (hp->bh_next == NULL) /* last block in used list */ | |
745 mfp->mf_used_last = hp->bh_prev; | |
746 else | |
747 hp->bh_next->bh_prev = hp->bh_prev; | |
748 if (hp->bh_prev == NULL) /* first block in used list */ | |
749 mfp->mf_used_first = hp->bh_next; | |
750 else | |
751 hp->bh_prev->bh_next = hp->bh_next; | |
752 mfp->mf_used_count -= hp->bh_page_count; | |
753 total_mem_used -= hp->bh_page_count * mfp->mf_page_size; | |
754 } | |
755 | |
756 /* | |
757 * Release the least recently used block from the used list if the number | |
758 * of used memory blocks gets to big. | |
759 * | |
760 * Return the block header to the caller, including the memory block, so | |
761 * it can be re-used. Make sure the page_count is right. | |
6817 | 762 * |
763 * Returns NULL if no block is released. | |
7 | 764 */ |
765 static bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
766 mf_release(memfile_T *mfp, int page_count) |
7 | 767 { |
768 bhdr_T *hp; | |
769 int need_release; | |
770 buf_T *buf; | |
771 | |
772 /* don't release while in mf_close_file() */ | |
1066 | 773 if (mf_dont_release) |
7 | 774 return NULL; |
775 | |
776 /* | |
777 * Need to release a block if the number of blocks for this memfile is | |
778 * higher than the maximum or total memory used is over 'maxmemtot' | |
779 */ | |
780 need_release = ((mfp->mf_used_count >= mfp->mf_used_count_max) | |
781 || (total_mem_used >> 10) >= (long_u)p_mmt); | |
782 | |
783 /* | |
784 * Try to create a swap file if the amount of memory used is getting too | |
785 * high. | |
786 */ | |
787 if (mfp->mf_fd < 0 && need_release && p_uc) | |
788 { | |
789 /* find for which buffer this memfile is */ | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9536
diff
changeset
|
790 FOR_ALL_BUFFERS(buf) |
7 | 791 if (buf->b_ml.ml_mfp == mfp) |
792 break; | |
793 if (buf != NULL && buf->b_may_swap) | |
794 ml_open_file(buf); | |
795 } | |
796 | |
797 /* | |
798 * don't release a block if | |
799 * there is no file for this memfile | |
800 * or | |
801 * the number of blocks for this memfile is lower than the maximum | |
802 * and | |
803 * total memory used is not up to 'maxmemtot' | |
804 */ | |
805 if (mfp->mf_fd < 0 || !need_release) | |
806 return NULL; | |
807 | |
808 for (hp = mfp->mf_used_last; hp != NULL; hp = hp->bh_prev) | |
809 if (!(hp->bh_flags & BH_LOCKED)) | |
810 break; | |
811 if (hp == NULL) /* not a single one that can be released */ | |
812 return NULL; | |
813 | |
814 /* | |
815 * If the block is dirty, write it. | |
816 * If the write fails we don't free it. | |
817 */ | |
818 if ((hp->bh_flags & BH_DIRTY) && mf_write(mfp, hp) == FAIL) | |
819 return NULL; | |
820 | |
821 mf_rem_used(mfp, hp); | |
822 mf_rem_hash(mfp, hp); | |
823 | |
824 /* | |
825 * If a bhdr_T is returned, make sure that the page_count of bh_data is | |
826 * right | |
827 */ | |
828 if (hp->bh_page_count != page_count) | |
829 { | |
830 vim_free(hp->bh_data); | |
831 if ((hp->bh_data = alloc(mfp->mf_page_size * page_count)) == NULL) | |
832 { | |
833 vim_free(hp); | |
834 return NULL; | |
835 } | |
836 hp->bh_page_count = page_count; | |
837 } | |
838 return hp; | |
839 } | |
840 | |
841 /* | |
842 * release as many blocks as possible | |
843 * Used in case of out of memory | |
844 * | |
845 * return TRUE if any memory was released | |
846 */ | |
847 int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
848 mf_release_all(void) |
7 | 849 { |
850 buf_T *buf; | |
851 memfile_T *mfp; | |
852 bhdr_T *hp; | |
853 int retval = FALSE; | |
854 | |
9649
fd9727ae3c49
commit https://github.com/vim/vim/commit/2932359000b2f918d5fade79ea4d124d5943cd07
Christian Brabandt <cb@256bit.org>
parents:
9536
diff
changeset
|
855 FOR_ALL_BUFFERS(buf) |
7 | 856 { |
857 mfp = buf->b_ml.ml_mfp; | |
858 if (mfp != NULL) | |
859 { | |
860 /* If no swap file yet, may open one */ | |
861 if (mfp->mf_fd < 0 && buf->b_may_swap) | |
862 ml_open_file(buf); | |
863 | |
864 /* only if there is a swapfile */ | |
865 if (mfp->mf_fd >= 0) | |
866 { | |
867 for (hp = mfp->mf_used_last; hp != NULL; ) | |
868 { | |
869 if (!(hp->bh_flags & BH_LOCKED) | |
870 && (!(hp->bh_flags & BH_DIRTY) | |
871 || mf_write(mfp, hp) != FAIL)) | |
872 { | |
873 mf_rem_used(mfp, hp); | |
874 mf_rem_hash(mfp, hp); | |
875 mf_free_bhdr(hp); | |
876 hp = mfp->mf_used_last; /* re-start, list was changed */ | |
877 retval = TRUE; | |
878 } | |
879 else | |
880 hp = hp->bh_prev; | |
881 } | |
882 } | |
883 } | |
884 } | |
885 return retval; | |
886 } | |
887 | |
888 /* | |
889 * Allocate a block header and a block of memory for it | |
890 */ | |
891 static bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
892 mf_alloc_bhdr(memfile_T *mfp, int page_count) |
7 | 893 { |
894 bhdr_T *hp; | |
895 | |
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
896 if ((hp = (bhdr_T *)alloc(sizeof(bhdr_T))) != NULL) |
7 | 897 { |
898 if ((hp->bh_data = (char_u *)alloc(mfp->mf_page_size * page_count)) | |
899 == NULL) | |
900 { | |
901 vim_free(hp); /* not enough memory */ | |
902 return NULL; | |
903 } | |
904 hp->bh_page_count = page_count; | |
905 } | |
906 return hp; | |
907 } | |
908 | |
909 /* | |
910 * Free a block header and the block of memory for it | |
911 */ | |
912 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
913 mf_free_bhdr(bhdr_T *hp) |
7 | 914 { |
915 vim_free(hp->bh_data); | |
916 vim_free(hp); | |
917 } | |
918 | |
919 /* | |
920 * insert entry *hp in the free list | |
921 */ | |
922 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
923 mf_ins_free(memfile_T *mfp, bhdr_T *hp) |
7 | 924 { |
925 hp->bh_next = mfp->mf_free_first; | |
926 mfp->mf_free_first = hp; | |
927 } | |
928 | |
929 /* | |
930 * remove the first entry from the free list and return a pointer to it | |
931 * Note: caller must check that mfp->mf_free_first is not NULL! | |
932 */ | |
933 static bhdr_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
934 mf_rem_free(memfile_T *mfp) |
7 | 935 { |
936 bhdr_T *hp; | |
937 | |
938 hp = mfp->mf_free_first; | |
939 mfp->mf_free_first = hp->bh_next; | |
940 return hp; | |
941 } | |
942 | |
943 /* | |
944 * read a block from disk | |
945 * | |
946 * Return FAIL for failure, OK otherwise | |
947 */ | |
948 static int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
949 mf_read(memfile_T *mfp, bhdr_T *hp) |
7 | 950 { |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
951 off_T offset; |
7 | 952 unsigned page_size; |
953 unsigned size; | |
954 | |
955 if (mfp->mf_fd < 0) /* there is no file, can't read */ | |
956 return FAIL; | |
957 | |
958 page_size = mfp->mf_page_size; | |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
959 offset = (off_T)page_size * hp->bh_bnum; |
7 | 960 size = page_size * hp->bh_page_count; |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
961 if (vim_lseek(mfp->mf_fd, offset, SEEK_SET) != offset) |
7 | 962 { |
1033 | 963 PERROR(_("E294: Seek error in swap file read")); |
7 | 964 return FAIL; |
965 } | |
2664 | 966 if ((unsigned)read_eintr(mfp->mf_fd, hp->bh_data, size) != size) |
7 | 967 { |
1033 | 968 PERROR(_("E295: Read error in swap file")); |
7 | 969 return FAIL; |
970 } | |
2267 | 971 |
972 #ifdef FEAT_CRYPT | |
7347
8977b399cf55
commit https://github.com/vim/vim/commit/4a8c2cfc56b9affc36934aa0f20d8cfd2b1511c8
Christian Brabandt <cb@256bit.org>
parents:
6817
diff
changeset
|
973 /* Decrypt if 'key' is set and this is a data block. And when changing the |
8977b399cf55
commit https://github.com/vim/vim/commit/4a8c2cfc56b9affc36934aa0f20d8cfd2b1511c8
Christian Brabandt <cb@256bit.org>
parents:
6817
diff
changeset
|
974 * key. */ |
8977b399cf55
commit https://github.com/vim/vim/commit/4a8c2cfc56b9affc36934aa0f20d8cfd2b1511c8
Christian Brabandt <cb@256bit.org>
parents:
6817
diff
changeset
|
975 if (*mfp->mf_buffer->b_p_key != NUL || mfp->mf_old_key != NULL) |
2267 | 976 ml_decrypt_data(mfp, hp->bh_data, offset, size); |
977 #endif | |
978 | |
7 | 979 return OK; |
980 } | |
981 | |
982 /* | |
983 * write a block to disk | |
984 * | |
985 * Return FAIL for failure, OK otherwise | |
986 */ | |
987 static int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
988 mf_write(memfile_T *mfp, bhdr_T *hp) |
7 | 989 { |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
990 off_T offset; /* offset in the file */ |
7 | 991 blocknr_T nr; /* block nr which is being written */ |
992 bhdr_T *hp2; | |
993 unsigned page_size; /* number of bytes in a page */ | |
994 unsigned page_count; /* number of pages written */ | |
995 unsigned size; /* number of bytes written */ | |
996 | |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
997 if (mfp->mf_fd < 0 && !mfp->mf_reopen) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
998 // there is no file and there was no file, can't write |
7 | 999 return FAIL; |
1000 | |
1001 if (hp->bh_bnum < 0) /* must assign file block number */ | |
1002 if (mf_trans_add(mfp, hp) == FAIL) | |
1003 return FAIL; | |
1004 | |
1005 page_size = mfp->mf_page_size; | |
1006 | |
1007 /* | |
1008 * We don't want gaps in the file. Write the blocks in front of *hp | |
1009 * to extend the file. | |
1010 * If block 'mf_infile_count' is not in the hash list, it has been | |
1011 * freed. Fill the space in the file with data from the current block. | |
1012 */ | |
1013 for (;;) | |
1014 { | |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1015 int attempt; |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1016 |
7 | 1017 nr = hp->bh_bnum; |
1018 if (nr > mfp->mf_infile_count) /* beyond end of file */ | |
1019 { | |
1020 nr = mfp->mf_infile_count; | |
4352 | 1021 hp2 = mf_find_hash(mfp, nr); /* NULL caught below */ |
7 | 1022 } |
1023 else | |
1024 hp2 = hp; | |
1025 | |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
1026 offset = (off_T)page_size * nr; |
7 | 1027 if (hp2 == NULL) /* freed block, fill with dummy data */ |
1028 page_count = 1; | |
1029 else | |
1030 page_count = hp2->bh_page_count; | |
1031 size = page_size * page_count; | |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1032 |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1033 for (attempt = 1; attempt <= 2; ++attempt) |
7 | 1034 { |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1035 if (mfp->mf_fd >= 0) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1036 { |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1037 if (vim_lseek(mfp->mf_fd, offset, SEEK_SET) != offset) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1038 { |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1039 PERROR(_("E296: Seek error in swap file write")); |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1040 return FAIL; |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1041 } |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1042 if (mf_write_block(mfp, |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1043 hp2 == NULL ? hp : hp2, offset, size) == OK) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1044 break; |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1045 } |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1046 |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1047 if (attempt == 1) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1048 { |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1049 // If the swap file is on a network drive, and the network |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1050 // gets disconnected and then re-connected, we can maybe fix it |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1051 // by closing and then re-opening the file. |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1052 if (mfp->mf_fd >= 0) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1053 close(mfp->mf_fd); |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1054 mfp->mf_fd = mch_open_rw((char *)mfp->mf_fname, mfp->mf_flags); |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1055 mfp->mf_reopen = (mfp->mf_fd < 0); |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1056 } |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1057 if (attempt == 2 || mfp->mf_fd < 0) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1058 { |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1059 // Avoid repeating the error message, this mostly happens when |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1060 // the disk is full. We give the message again only after a |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1061 // successful write or when hitting a key. We keep on trying, |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1062 // in case some space becomes available. |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1063 if (!did_swapwrite_msg) |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1064 emsg(_("E297: Write error in swap file")); |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1065 did_swapwrite_msg = TRUE; |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1066 return FAIL; |
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1067 } |
7 | 1068 } |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1069 |
7 | 1070 did_swapwrite_msg = FALSE; |
1071 if (hp2 != NULL) /* written a non-dummy block */ | |
1072 hp2->bh_flags &= ~BH_DIRTY; | |
1073 /* appended to the file */ | |
1074 if (nr + (blocknr_T)page_count > mfp->mf_infile_count) | |
1075 mfp->mf_infile_count = nr + page_count; | |
1076 if (nr == hp->bh_bnum) /* written the desired block */ | |
1077 break; | |
1078 } | |
1079 return OK; | |
1080 } | |
1081 | |
1082 /* | |
2267 | 1083 * Write block "hp" with data size "size" to file "mfp->mf_fd". |
1084 * Takes care of encryption. | |
1085 * Return FAIL or OK. | |
1086 */ | |
1087 static int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1088 mf_write_block( |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1089 memfile_T *mfp, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1090 bhdr_T *hp, |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
1091 off_T offset UNUSED, |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1092 unsigned size) |
2267 | 1093 { |
1094 char_u *data = hp->bh_data; | |
1095 int result = OK; | |
1096 | |
1097 #ifdef FEAT_CRYPT | |
1098 /* Encrypt if 'key' is set and this is a data block. */ | |
1099 if (*mfp->mf_buffer->b_p_key != NUL) | |
1100 { | |
1101 data = ml_encrypt_data(mfp, data, offset, size); | |
1102 if (data == NULL) | |
1103 return FAIL; | |
1104 } | |
1105 #endif | |
1106 | |
2664 | 1107 if ((unsigned)write_eintr(mfp->mf_fd, data, size) != size) |
2267 | 1108 result = FAIL; |
1109 | |
1110 #ifdef FEAT_CRYPT | |
1111 if (data != hp->bh_data) | |
1112 vim_free(data); | |
1113 #endif | |
1114 | |
1115 return result; | |
1116 } | |
1117 | |
1118 /* | |
7 | 1119 * Make block number for *hp positive and add it to the translation list |
1120 * | |
1121 * Return FAIL for failure, OK otherwise | |
1122 */ | |
1123 static int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1124 mf_trans_add(memfile_T *mfp, bhdr_T *hp) |
7 | 1125 { |
1126 bhdr_T *freep; | |
1127 blocknr_T new_bnum; | |
1128 NR_TRANS *np; | |
1129 int page_count; | |
1130 | |
1131 if (hp->bh_bnum >= 0) /* it's already positive */ | |
1132 return OK; | |
1133 | |
16764
ef00b6bc186b
patch 8.1.1384: using "int" for alloc() often results in compiler warnings
Bram Moolenaar <Bram@vim.org>
parents:
15868
diff
changeset
|
1134 if ((np = (NR_TRANS *)alloc(sizeof(NR_TRANS))) == NULL) |
7 | 1135 return FAIL; |
1136 | |
1137 /* | |
2267 | 1138 * Get a new number for the block. |
7 | 1139 * If the first item in the free list has sufficient pages, use its number |
1140 * Otherwise use mf_blocknr_max. | |
1141 */ | |
1142 freep = mfp->mf_free_first; | |
1143 page_count = hp->bh_page_count; | |
1144 if (freep != NULL && freep->bh_page_count >= page_count) | |
1145 { | |
1146 new_bnum = freep->bh_bnum; | |
1147 /* | |
4352 | 1148 * If the page count of the free block was larger, reduce it. |
7 | 1149 * If the page count matches, remove the block from the free list |
1150 */ | |
1151 if (freep->bh_page_count > page_count) | |
1152 { | |
1153 freep->bh_bnum += page_count; | |
1154 freep->bh_page_count -= page_count; | |
1155 } | |
1156 else | |
1157 { | |
1158 freep = mf_rem_free(mfp); | |
1159 vim_free(freep); | |
1160 } | |
1161 } | |
1162 else | |
1163 { | |
1164 new_bnum = mfp->mf_blocknr_max; | |
1165 mfp->mf_blocknr_max += page_count; | |
1166 } | |
1167 | |
1168 np->nt_old_bnum = hp->bh_bnum; /* adjust number */ | |
1169 np->nt_new_bnum = new_bnum; | |
1170 | |
1171 mf_rem_hash(mfp, hp); /* remove from old hash list */ | |
1172 hp->bh_bnum = new_bnum; | |
1173 mf_ins_hash(mfp, hp); /* insert in new hash list */ | |
1174 | |
2730 | 1175 /* Insert "np" into "mf_trans" hashtable with key "np->nt_old_bnum" */ |
1176 mf_hash_add_item(&mfp->mf_trans, (mf_hashitem_T *)np); | |
7 | 1177 |
1178 return OK; | |
1179 } | |
1180 | |
1181 /* | |
6817 | 1182 * Lookup a translation from the trans lists and delete the entry. |
7 | 1183 * |
1184 * Return the positive new number when found, the old number when not found | |
1185 */ | |
1186 blocknr_T | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1187 mf_trans_del(memfile_T *mfp, blocknr_T old_nr) |
7 | 1188 { |
1189 NR_TRANS *np; | |
1190 blocknr_T new_bnum; | |
1191 | |
2730 | 1192 np = (NR_TRANS *)mf_hash_find(&mfp->mf_trans, old_nr); |
1193 | |
7 | 1194 if (np == NULL) /* not found */ |
1195 return old_nr; | |
1196 | |
1197 mfp->mf_neg_count--; | |
1198 new_bnum = np->nt_new_bnum; | |
2730 | 1199 |
1200 /* remove entry from the trans list */ | |
1201 mf_hash_rem_item(&mfp->mf_trans, (mf_hashitem_T *)np); | |
1202 | |
7 | 1203 vim_free(np); |
1204 | |
1205 return new_bnum; | |
1206 } | |
1207 | |
1208 /* | |
1209 * Set mfp->mf_ffname according to mfp->mf_fname and some other things. | |
1210 * Only called when creating or renaming the swapfile. Either way it's a new | |
1211 * name so we must work out the full path name. | |
1212 */ | |
1213 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1214 mf_set_ffname(memfile_T *mfp) |
7 | 1215 { |
1216 mfp->mf_ffname = FullName_save(mfp->mf_fname, FALSE); | |
1217 } | |
1218 | |
1219 /* | |
1220 * Make the name of the file used for the memfile a full path. | |
1221 * Used before doing a :cd | |
1222 */ | |
1223 void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1224 mf_fullname(memfile_T *mfp) |
7 | 1225 { |
1226 if (mfp != NULL && mfp->mf_fname != NULL && mfp->mf_ffname != NULL) | |
1227 { | |
1228 vim_free(mfp->mf_fname); | |
1229 mfp->mf_fname = mfp->mf_ffname; | |
1230 mfp->mf_ffname = NULL; | |
1231 } | |
1232 } | |
1233 | |
1234 /* | |
1235 * return TRUE if there are any translations pending for 'mfp' | |
1236 */ | |
1237 int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1238 mf_need_trans(memfile_T *mfp) |
7 | 1239 { |
1240 return (mfp->mf_fname != NULL && mfp->mf_neg_count > 0); | |
1241 } | |
1242 | |
1243 /* | |
1244 * Open a swap file for a memfile. | |
1245 * The "fname" must be in allocated memory, and is consumed (also when an | |
1246 * error occurs). | |
1247 */ | |
1248 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1249 mf_do_open( |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1250 memfile_T *mfp, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1251 char_u *fname, |
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1252 int flags) /* flags for open() */ |
7 | 1253 { |
1254 #ifdef HAVE_LSTAT | |
9387
f094d4085014
commit https://github.com/vim/vim/commit/8767f52fbfd4f053ce00a978227c95f1d7d323fe
Christian Brabandt <cb@256bit.org>
parents:
8212
diff
changeset
|
1255 stat_T sb; |
7 | 1256 #endif |
1257 | |
1258 mfp->mf_fname = fname; | |
1259 | |
1260 /* | |
1261 * Get the full path name before the open, because this is | |
1262 * not possible after the open on the Amiga. | |
1263 * fname cannot be NameBuff, because it must have been allocated. | |
1264 */ | |
1265 mf_set_ffname(mfp); | |
8212
05b88224cea1
commit https://github.com/vim/vim/commit/48e330aff911be1c798c88a973af6437a8141fce
Christian Brabandt <cb@256bit.org>
parents:
7961
diff
changeset
|
1266 #if defined(MSWIN) |
7 | 1267 /* |
4352 | 1268 * A ":!cd e:xxx" may change the directory without us knowing, use the |
7 | 1269 * full pathname always. Careful: This frees fname! |
1270 */ | |
1271 mf_fullname(mfp); | |
1272 #endif | |
1273 | |
1274 #ifdef HAVE_LSTAT | |
1275 /* | |
1276 * Extra security check: When creating a swap file it really shouldn't | |
1277 * exist yet. If there is a symbolic link, this is most likely an attack. | |
1278 */ | |
1279 if ((flags & O_CREAT) && mch_lstat((char *)mfp->mf_fname, &sb) >= 0) | |
1280 { | |
1281 mfp->mf_fd = -1; | |
15470
55ccc2d353bd
patch 8.1.0743: giving error messages is not flexible
Bram Moolenaar <Bram@vim.org>
parents:
14822
diff
changeset
|
1282 emsg(_("E300: Swap file already exists (symlink attack?)")); |
7 | 1283 } |
1284 else | |
1285 #endif | |
1286 { | |
1287 /* | |
1288 * try to open the file | |
1289 */ | |
557 | 1290 flags |= O_EXTRA | O_NOFOLLOW; |
15868
7fad90423bd2
patch 8.1.0941: macros for MS-Windows are inconsistent
Bram Moolenaar <Bram@vim.org>
parents:
15816
diff
changeset
|
1291 #ifdef MSWIN |
7 | 1292 /* Prevent handle inheritance that cause problems with Cscope |
1293 * (swap file may not be deleted if cscope connection was open after | |
1294 * the file) */ | |
1295 flags |= O_NOINHERIT; | |
1296 #endif | |
16823
b1b7c7a31679
patch 8.1.1413: error when the drive of the swap file was disconnected
Bram Moolenaar <Bram@vim.org>
parents:
16764
diff
changeset
|
1297 mfp->mf_flags = flags; |
7 | 1298 mfp->mf_fd = mch_open_rw((char *)mfp->mf_fname, flags); |
1299 } | |
1300 | |
1301 /* | |
1302 * If the file cannot be opened, use memory only | |
1303 */ | |
1304 if (mfp->mf_fd < 0) | |
1305 { | |
13244
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
1306 VIM_CLEAR(mfp->mf_fname); |
ac42c4b11dbc
patch 8.0.1496: clearing a pointer takes two lines
Christian Brabandt <cb@256bit.org>
parents:
10359
diff
changeset
|
1307 VIM_CLEAR(mfp->mf_ffname); |
7 | 1308 } |
1309 else | |
1583 | 1310 { |
2003 | 1311 #ifdef HAVE_FD_CLOEXEC |
1312 int fdflags = fcntl(mfp->mf_fd, F_GETFD); | |
1313 if (fdflags >= 0 && (fdflags & FD_CLOEXEC) == 0) | |
7961
a7e58c6e4e9a
commit https://github.com/vim/vim/commit/fbc4b4db3a9690906a96e16724350a6241cf32a5
Christian Brabandt <cb@256bit.org>
parents:
7827
diff
changeset
|
1314 (void)fcntl(mfp->mf_fd, F_SETFD, fdflags | FD_CLOEXEC); |
2003 | 1315 #endif |
5788 | 1316 #if defined(HAVE_SELINUX) || defined(HAVE_SMACK) |
1583 | 1317 mch_copy_sec(fname, mfp->mf_fname); |
1318 #endif | |
7 | 1319 mch_hide(mfp->mf_fname); /* try setting the 'hidden' flag */ |
1583 | 1320 } |
7 | 1321 } |
2730 | 1322 |
1323 /* | |
1324 * Implementation of mf_hashtab_T follows. | |
1325 */ | |
1326 | |
1327 /* | |
1328 * The number of buckets in the hashtable is increased by a factor of | |
1329 * MHT_GROWTH_FACTOR when the average number of items per bucket | |
1330 * exceeds 2 ^ MHT_LOG_LOAD_FACTOR. | |
1331 */ | |
1332 #define MHT_LOG_LOAD_FACTOR 6 | |
1333 #define MHT_GROWTH_FACTOR 2 /* must be a power of two */ | |
1334 | |
1335 /* | |
1336 * Initialize an empty hash table. | |
1337 */ | |
1338 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1339 mf_hash_init(mf_hashtab_T *mht) |
2730 | 1340 { |
1341 vim_memset(mht, 0, sizeof(mf_hashtab_T)); | |
1342 mht->mht_buckets = mht->mht_small_buckets; | |
1343 mht->mht_mask = MHT_INIT_SIZE - 1; | |
1344 } | |
1345 | |
1346 /* | |
1347 * Free the array of a hash table. Does not free the items it contains! | |
1348 * The hash table must not be used again without another mf_hash_init() call. | |
1349 */ | |
1350 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1351 mf_hash_free(mf_hashtab_T *mht) |
2730 | 1352 { |
1353 if (mht->mht_buckets != mht->mht_small_buckets) | |
1354 vim_free(mht->mht_buckets); | |
1355 } | |
1356 | |
1357 /* | |
1358 * Free the array of a hash table and all the items it contains. | |
1359 */ | |
1360 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1361 mf_hash_free_all(mf_hashtab_T *mht) |
2730 | 1362 { |
1363 long_u idx; | |
1364 mf_hashitem_T *mhi; | |
1365 mf_hashitem_T *next; | |
1366 | |
1367 for (idx = 0; idx <= mht->mht_mask; idx++) | |
1368 for (mhi = mht->mht_buckets[idx]; mhi != NULL; mhi = next) | |
1369 { | |
1370 next = mhi->mhi_next; | |
1371 vim_free(mhi); | |
1372 } | |
1373 | |
1374 mf_hash_free(mht); | |
1375 } | |
1376 | |
1377 /* | |
1378 * Find "key" in hashtable "mht". | |
1379 * Returns a pointer to a mf_hashitem_T or NULL if the item was not found. | |
1380 */ | |
1381 static mf_hashitem_T * | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1382 mf_hash_find(mf_hashtab_T *mht, blocknr_T key) |
2730 | 1383 { |
1384 mf_hashitem_T *mhi; | |
1385 | |
1386 mhi = mht->mht_buckets[key & mht->mht_mask]; | |
1387 while (mhi != NULL && mhi->mhi_key != key) | |
1388 mhi = mhi->mhi_next; | |
1389 | |
1390 return mhi; | |
1391 } | |
1392 | |
1393 /* | |
1394 * Add item "mhi" to hashtable "mht". | |
1395 * "mhi" must not be NULL. | |
1396 */ | |
1397 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1398 mf_hash_add_item(mf_hashtab_T *mht, mf_hashitem_T *mhi) |
2730 | 1399 { |
1400 long_u idx; | |
1401 | |
1402 idx = mhi->mhi_key & mht->mht_mask; | |
1403 mhi->mhi_next = mht->mht_buckets[idx]; | |
1404 mhi->mhi_prev = NULL; | |
1405 if (mhi->mhi_next != NULL) | |
1406 mhi->mhi_next->mhi_prev = mhi; | |
1407 mht->mht_buckets[idx] = mhi; | |
1408 | |
1409 mht->mht_count++; | |
1410 | |
1411 /* | |
1412 * Grow hashtable when we have more thank 2^MHT_LOG_LOAD_FACTOR | |
1413 * items per bucket on average | |
1414 */ | |
1415 if (mht->mht_fixed == 0 | |
1416 && (mht->mht_count >> MHT_LOG_LOAD_FACTOR) > mht->mht_mask) | |
1417 { | |
1418 if (mf_hash_grow(mht) == FAIL) | |
1419 { | |
1420 /* stop trying to grow after first failure to allocate memory */ | |
1421 mht->mht_fixed = 1; | |
1422 } | |
1423 } | |
1424 } | |
1425 | |
1426 /* | |
1427 * Remove item "mhi" from hashtable "mht". | |
1428 * "mhi" must not be NULL and must have been inserted into "mht". | |
1429 */ | |
1430 static void | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1431 mf_hash_rem_item(mf_hashtab_T *mht, mf_hashitem_T *mhi) |
2730 | 1432 { |
1433 if (mhi->mhi_prev == NULL) | |
1434 mht->mht_buckets[mhi->mhi_key & mht->mht_mask] = mhi->mhi_next; | |
1435 else | |
1436 mhi->mhi_prev->mhi_next = mhi->mhi_next; | |
1437 | |
1438 if (mhi->mhi_next != NULL) | |
1439 mhi->mhi_next->mhi_prev = mhi->mhi_prev; | |
1440 | |
1441 mht->mht_count--; | |
1442 | |
1443 /* We could shrink the table here, but it typically takes little memory, | |
1444 * so why bother? */ | |
1445 } | |
1446 | |
1447 /* | |
1448 * Increase number of buckets in the hashtable by MHT_GROWTH_FACTOR and | |
1449 * rehash items. | |
1450 * Returns FAIL when out of memory. | |
1451 */ | |
1452 static int | |
7827
41789f16d6b2
commit https://github.com/vim/vim/commit/52ea13da0fe86df1abf34de52841e367035170c0
Christian Brabandt <cb@256bit.org>
parents:
7803
diff
changeset
|
1453 mf_hash_grow(mf_hashtab_T *mht) |
2730 | 1454 { |
1455 long_u i, j; | |
1456 int shift; | |
1457 mf_hashitem_T *mhi; | |
1458 mf_hashitem_T *tails[MHT_GROWTH_FACTOR]; | |
1459 mf_hashitem_T **buckets; | |
1460 size_t size; | |
1461 | |
1462 size = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR * sizeof(void *); | |
1463 buckets = (mf_hashitem_T **)lalloc_clear(size, FALSE); | |
1464 if (buckets == NULL) | |
1465 return FAIL; | |
1466 | |
1467 shift = 0; | |
1468 while ((mht->mht_mask >> shift) != 0) | |
1469 shift++; | |
1470 | |
1471 for (i = 0; i <= mht->mht_mask; i++) | |
1472 { | |
1473 /* | |
1474 * Traverse the items in the i-th original bucket and move them into | |
1475 * MHT_GROWTH_FACTOR new buckets, preserving their relative order | |
1476 * within each new bucket. Preserving the order is important because | |
1477 * mf_get() tries to keep most recently used items at the front of | |
1478 * each bucket. | |
1479 * | |
1480 * Here we strongly rely on the fact the hashes are computed modulo | |
1481 * a power of two. | |
1482 */ | |
1483 | |
1484 vim_memset(tails, 0, sizeof(tails)); | |
1485 | |
1486 for (mhi = mht->mht_buckets[i]; mhi != NULL; mhi = mhi->mhi_next) | |
1487 { | |
1488 j = (mhi->mhi_key >> shift) & (MHT_GROWTH_FACTOR - 1); | |
1489 if (tails[j] == NULL) | |
1490 { | |
1491 buckets[i + (j << shift)] = mhi; | |
1492 tails[j] = mhi; | |
1493 mhi->mhi_prev = NULL; | |
1494 } | |
1495 else | |
1496 { | |
1497 tails[j]->mhi_next = mhi; | |
1498 mhi->mhi_prev = tails[j]; | |
1499 tails[j] = mhi; | |
1500 } | |
1501 } | |
1502 | |
1503 for (j = 0; j < MHT_GROWTH_FACTOR; j++) | |
1504 if (tails[j] != NULL) | |
1505 tails[j]->mhi_next = NULL; | |
1506 } | |
1507 | |
1508 if (mht->mht_buckets != mht->mht_small_buckets) | |
1509 vim_free(mht->mht_buckets); | |
1510 | |
1511 mht->mht_buckets = buckets; | |
1512 mht->mht_mask = (mht->mht_mask + 1) * MHT_GROWTH_FACTOR - 1; | |
1513 | |
1514 return OK; | |
1515 } |