Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : /*
14 : * @a M. L. Kersten, P. Boncz, N. J. Nes
15 : * @* BAT Buffer Pool (BBP)
16 : * The BATs created and loaded are collected in a BAT buffer pool.
17 : * The Bat Buffer Pool has a number of functions:
18 : * @table @code
19 : *
20 : * @item administration and lookup
21 : * The BBP is a directory which contains status information about all
22 : * known BATs. This interface may be used very heavily, by
23 : * data-intensive applications. To eliminate all overhead, read-only
24 : * access to the BBP may be done by table-lookups. The integer index
25 : * type for these lookups is @emph{bat}, as retrieved by
26 : * @emph{b->batCacheid}. The @emph{bat} zero is reserved for the nil
27 : * bat.
28 : *
29 : * @item persistence
30 : * The BBP is made persistent by saving it to the dictionary file
31 : * called @emph{BBP.dir} in the database.
32 : *
33 : * When the number of BATs rises, having all files in one directory
34 : * becomes a bottleneck. The BBP therefore implements a scheme that
35 : * distributes all BATs in a growing directory tree with at most 64
36 : * BATs stored in one node.
37 : *
38 : * @item buffer management
39 : * The BBP is responsible for loading and saving of BATs to disk. It
40 : * also contains routines to unload BATs from memory when memory
41 : * resources get scarce. For this purpose, it administers BAT memory
42 : * reference counts (to know which BATs can be unloaded) and BAT usage
43 : * statistics (it unloads the least recently used BATs).
44 : *
45 : * @item recovery
46 : * When the database is closed or during a run-time syncpoint, the
47 : * system tables must be written to disk in a safe way, that is immune
48 : * for system failures (like disk full). To do so, the BBP implements
49 : * an atomic commit and recovery protocol: first all files to be
50 : * overwritten are moved to a BACKUP/ dir. If that succeeds, the
51 : * writes are done. If that also fully succeeds the BACKUP/ dir is
52 : * renamed to DELETE_ME/ and subsequently deleted. If not, all files
53 : * in BACKUP/ are moved back to their original location.
54 : *
55 : * @item unloading
56 : * Bats which have a logical reference (ie. a lrefs > 0) but no memory
57 : * reference (refcnt == 0) can be unloaded. Unloading dirty bats
58 : * means, moving the original (committed version) to the BACKUP/ dir
59 : * and saving the bat. This complicates the commit and recovery/abort
60 : * issues. The commit has to check if the bat is already moved. And
61 : * The recovery has to always move back the files from the BACKUP/
62 : * dir.
63 : *
64 : * @item reference counting
65 : * Bats use have two kinds of references: logical and physical
66 : * (pointer) ones. The logical references are administered by
67 : * BBPretain/BBPrelease, the physical ones by BBPfix/BBPunfix.
68 : */
69 :
70 : #include "monetdb_config.h"
71 : #include "gdk.h"
72 : #include "gdk_private.h"
73 : #include "mutils.h"
74 : #ifdef HAVE_FCNTL_H
75 : #include <fcntl.h>
76 : #endif
77 :
78 : #ifndef F_OK
79 : #define F_OK 0
80 : #endif
81 : #ifndef S_ISDIR
82 : #define S_ISDIR(mode) (((mode) & _S_IFMT) == _S_IFDIR)
83 : #endif
84 : #ifndef O_CLOEXEC
85 : #ifdef _O_NOINHERIT
86 : #define O_CLOEXEC _O_NOINHERIT /* Windows */
87 : #else
88 : #define O_CLOEXEC 0
89 : #endif
90 : #endif
91 : #ifndef O_BINARY
92 : #define O_BINARY 0
93 : #endif
94 :
95 : /*
96 : * The BBP has a fixed address, so re-allocation due to a growing BBP
97 : * caused by one thread does not disturb reads to the old entries by
98 : * another. This is implemented using anonymous virtual memory;
99 : * extensions on the same address are guaranteed because a large
100 : * non-committed VM area is requested initially. New slots in the BBP
101 : * are found in O(1) by keeping a freelist that uses the 'next' field
102 : * in the BBPrec records.
103 : */
104 : static BBPrec BBP0[BBPINIT];
105 : BBPrec *BBP[N_BBPINIT] = {[0] = BBP0}; /* fixed base VM address of BBP array */
106 : bat BBPlimit = BBPINIT; /* current committed VM BBP array */
107 : static ATOMIC_TYPE BBPsize = ATOMIC_VAR_INIT(0); /* current used size of BBP array */
108 :
109 : struct BBPfarm_t BBPfarms[MAXFARMS];
110 :
111 : #define KITTENNAP 1 /* used to suspend processing */
112 : #define BBPNONAME "." /* filler for no name in BBP.dir */
113 : /*
114 : * The hash index uses a bucket index (int array) of size mask that is
115 : * tuned for perfect hashing (1 lookup). The bucket chain uses the
116 : * 'next' field in the BBPrec records.
117 : */
118 : static MT_Lock BBPnameLock = MT_LOCK_INITIALIZER(BBPnameLock);
119 : #define BBP_mask 1023 /* number of buckets = & mask */
120 : static bat BBP_hash[BBP_mask+1]; /* BBP logical name hash buckets */
121 : static MT_Lock GDKcacheLock = MT_LOCK_INITIALIZER(GDKcacheLock);
122 : static bat BBP_free;
123 : static uint32_t BBP_nfree;
124 : #define BBP_FREE_LOWATER 10
125 : #define BBP_FREE_HIWATER 50
126 :
127 : static gdk_return BBPfree(BAT *b);
128 : static void BBPdestroy(BAT *b);
129 : static void BBPuncacheit(bat bid, bool unloaddesc);
130 : static gdk_return BBPprepare(bool subcommit);
131 : static BAT *getBBPdescriptor(bat i);
132 : static gdk_return BBPbackup(BAT *b, bool subcommit);
133 : static gdk_return BBPdir_init(void);
134 : static void BBPcallbacks(void);
135 :
136 : /* two lngs of extra info in BBP.dir */
137 : /* these two are atomic because of their use in log_new() */
138 : static ATOMIC_TYPE BBPlogno = ATOMIC_VAR_INIT(0);
139 :
140 : #define BBPtmpcheck(s) (strncmp(s, "tmp_", 4) == 0)
141 :
142 : #define BBPnamecheck(s) (BBPtmpcheck(s) ? strtol((s) + 4, NULL, 8) : 0)
143 :
144 : #define BATno_shared_heap(b) \
145 : (!VIEWtparent(b) && (ATOMIC_GET(&(b)->theap->refs) & HEAPREFS) == 1)
146 :
147 : #define BATshared(b) \
148 : ((!VIEWtparent(b) && (ATOMIC_GET(&(b)->theap->refs) & HEAPREFS) > 1) || \
149 : ((b)->tvheap && !VIEWvtparent(b) && (ATOMIC_GET(&(b)->tvheap->refs) & HEAPREFS) > 1))
150 :
151 : static void
152 28391 : BBP_insert(bat i)
153 : {
154 28391 : bat idx = (bat) (strHash(BBP_logical(i)) & BBP_mask);
155 :
156 28391 : BBP_next(i) = BBP_hash[idx];
157 28391 : BBP_hash[idx] = i;
158 28391 : }
159 :
160 : static void
161 16747 : BBP_delete(bat i)
162 : {
163 16747 : const char *s = BBP_logical(i);
164 16747 : bat idx = (bat) (strHash(s) & BBP_mask);
165 :
166 16747 : for (bat *h = &BBP_hash[idx]; (i = *h) != 0; h = &BBP_next(i)) {
167 16747 : if (strcmp(BBP_logical(i), s) == 0) {
168 16747 : *h = BBP_next(i);
169 16747 : break;
170 : }
171 : }
172 16747 : }
173 :
174 : bat
175 410847440 : getBBPsize(void)
176 : {
177 410847440 : return (bat) ATOMIC_GET(&BBPsize);
178 : }
179 :
180 : lng
181 399 : getBBPlogno(void)
182 : {
183 399 : return (lng) ATOMIC_GET(&BBPlogno);
184 : }
185 :
186 :
187 : /*
188 : * @+ BBP Consistency and Concurrency
189 : * While GDK provides the basic building blocks for an ACID system, in
190 : * itself it is not such a system, as we this would entail too much
191 : * overhead that is often not needed. Hence, some consistency control
192 : * is left to the user. The first important user constraint is that if
193 : * a user updates a BAT, (s)he himself must assure that no-one else
194 : * accesses this BAT.
195 : *
196 : * Concerning buffer management, the BBP carries out a swapping
197 : * policy. BATs are kept in memory till the memory is full. If the
198 : * memory is full, the malloc functions initiate BBP trim actions,
199 : * that unload the coldest BATs that have a zero reference count. The
200 : * second important user constraint is therefore that a user may only
201 : * manipulate live BAT data in memory if it is sure that there is at
202 : * least one reference count to that BAT.
203 : *
204 : * The main BBP array is protected by two locks:
205 : * @table @code
206 : * @item GDKcacheLock]
207 : * this lock guards the free slot management in the BBP array. The
208 : * BBP operations that allocate a new slot for a new BAT
209 : * (@emph{BBPinit},@emph{BBPcacheit}), delete the slot of a destroyed
210 : * BAT (@emph{BBPreclaim}), or rename a BAT (@emph{BBPrename}), hold
211 : * this lock. It also protects all BAT (re)naming actions include
212 : * (read and write) in the hash table with BAT names.
213 : * @item GDKswapLock
214 : * this lock guards the swap (loaded/unloaded) status of the
215 : * BATs. Hence, all BBP routines that influence the swapping policy,
216 : * or actually carry out the swapping policy itself, acquire this lock
217 : * (e.g. @emph{BBPfix},@emph{BBPunfix}). Note that this also means
218 : * that updates to the BBP_status indicator array must be protected by
219 : * GDKswapLock.
220 : *
221 : * To reduce contention GDKswapLock was split into multiple locks; it
222 : * is now an array of lock pointers which is accessed by
223 : * GDKswapLock(bat)
224 : * @end table
225 : *
226 : * Routines that need both locks should first acquire the locks in the
227 : * GDKswapLock array (in ascending order) and then GDKcacheLock (and
228 : * release them in reverse order).
229 : *
230 : * To obtain maximum speed, read operations to existing elements in
231 : * the BBP are unguarded. As said, it is the users responsibility that
232 : * the BAT that is being read is not being modified. BBP update
233 : * actions that modify the BBP data structure itself are locked by the
234 : * BBP functions themselves. Hence, multiple concurrent BBP read
235 : * operations may be ongoing while at the same time at most one BBP
236 : * write operation @strong{on a different BAT} is executing. This
237 : * holds for accesses to the public (quasi-) arrays @emph{BBPcache},
238 : * @emph{BBPstatus} and @emph{BBPrefs}.
239 : * These arrays are called quasi as now they are
240 : * actually stored together in one big BBPrec array called BBP, that
241 : * is allocated in anonymous VM space, so we can reallocate this
242 : * structure without changing the base address (a crucial feature if
243 : * read actions are to go on unlocked while other entries in the BBP
244 : * may be modified).
245 : */
246 : static volatile MT_Id locked_by = 0;
247 :
248 : /* use a lock instead of atomic instructions so that we wait for
249 : * BBPlock/BBPunlock */
250 : #define BBP_unload_inc() \
251 : do { \
252 : MT_lock_set(&GDKunloadLock); \
253 : BBPunloadCnt++; \
254 : MT_lock_unset(&GDKunloadLock); \
255 : } while (0)
256 :
257 : #define BBP_unload_dec() \
258 : do { \
259 : MT_lock_set(&GDKunloadLock); \
260 : --BBPunloadCnt; \
261 : assert(BBPunloadCnt >= 0); \
262 : MT_lock_unset(&GDKunloadLock); \
263 : } while (0)
264 :
265 : static int BBPunloadCnt = 0;
266 : static MT_Lock GDKunloadLock = MT_LOCK_INITIALIZER(GDKunloadLock);
267 :
268 : void
269 8 : BBPlock(void)
270 : {
271 8 : int i;
272 :
273 : /* wait for all pending unloads to finish */
274 8 : MT_lock_set(&GDKunloadLock);
275 8 : while (BBPunloadCnt > 0) {
276 0 : MT_lock_unset(&GDKunloadLock);
277 0 : MT_sleep_ms(1);
278 8 : MT_lock_set(&GDKunloadLock);
279 : }
280 :
281 8 : BBPtmlock();
282 8 : MT_lock_set(&GDKcacheLock);
283 65552 : for (i = 0; i <= BBP_BATMASK; i++)
284 65536 : MT_lock_set(&GDKswapLock(i));
285 8 : locked_by = MT_getpid();
286 :
287 8 : MT_lock_unset(&GDKunloadLock);
288 8 : }
289 :
290 : void
291 8 : BBPunlock(void)
292 : {
293 8 : int i;
294 :
295 65544 : for (i = BBP_BATMASK; i >= 0; i--)
296 65536 : MT_lock_unset(&GDKswapLock(i));
297 8 : MT_lock_unset(&GDKcacheLock);
298 8 : locked_by = 0;
299 8 : BBPtmunlock();
300 8 : }
301 :
302 : int
303 12533305 : BBPselectfarm(role_t role, int type, enum heaptype hptype)
304 : {
305 12533305 : int i;
306 :
307 12533305 : (void) type; /* may use in future */
308 12533305 : (void) hptype; /* may use in future */
309 :
310 12533305 : if (GDKinmemory(0))
311 : return 0;
312 :
313 24714412 : for (i = 0; i < MAXFARMS; i++)
314 24714412 : if (BBPfarms[i].roles & (1U << (int) role))
315 12513242 : return i;
316 : /* must be able to find farms for TRANSIENT and PERSISTENT */
317 0 : assert(role != TRANSIENT && role != PERSISTENT);
318 : return -1;
319 : }
320 :
321 : static gdk_return
322 357 : BBPextend(bat newsize)
323 : {
324 357 : if (newsize > N_BBPINIT * BBPINIT) {
325 0 : GDKerror("trying to extend BAT pool beyond the "
326 : "limit (%d)\n", N_BBPINIT * BBPINIT);
327 0 : return GDK_FAIL;
328 : }
329 :
330 : /* make sure the new size is at least BBPsize large */
331 357 : while (BBPlimit < newsize) {
332 0 : BUN limit = BBPlimit >> BBPINITLOG;
333 0 : assert(BBP[limit] == NULL);
334 0 : BBP[limit] = GDKzalloc(BBPINIT * sizeof(BBPrec));
335 0 : if (BBP[limit] == NULL) {
336 0 : GDKerror("failed to extend BAT pool\n");
337 0 : return GDK_FAIL;
338 : }
339 0 : for (BUN i = 0; i < BBPINIT; i++) {
340 0 : ATOMIC_INIT(&BBP[limit][i].status, 0);
341 0 : BBP[limit][i].pid = ~(MT_Id)0;
342 : }
343 0 : BBPlimit += BBPINIT;
344 : }
345 :
346 : return GDK_SUCCEED;
347 : }
348 :
349 : static gdk_return
350 127 : recover_dir(int farmid, bool direxists)
351 : {
352 127 : if (direxists) {
353 : /* just try; don't care about these non-vital files */
354 0 : if (GDKunlink(farmid, BATDIR, "BBP", "bak") != GDK_SUCCEED)
355 0 : GDKwarning("unlink of BBP.bak failed\n");
356 0 : if (GDKmove(farmid, BATDIR, "BBP", "dir", BATDIR, "BBP", "bak", false) != GDK_SUCCEED)
357 0 : GDKwarning("rename of BBP.dir to BBP.bak failed\n");
358 : }
359 127 : return GDKmove(farmid, BAKDIR, "BBP", "dir", BATDIR, "BBP", "dir", true);
360 : }
361 :
362 : static inline str
363 512278 : BBPsubdir_recursive(char *s, bat i)
364 : {
365 512278 : i >>= 6;
366 512278 : if (i >= 0100) {
367 65672 : s = BBPsubdir_recursive(s, i);
368 65673 : *s++ = DIR_SEP;
369 : }
370 512279 : i &= 077;
371 512279 : *s++ = '0' + (i >> 3);
372 512279 : *s++ = '0' + (i & 7);
373 512279 : return s;
374 : }
375 :
376 : static inline void
377 0 : BBPgetsubdir(char *s, bat i)
378 : {
379 0 : if (i >= 0100) {
380 0 : s = BBPsubdir_recursive(s, i);
381 : }
382 0 : *s = 0;
383 0 : }
384 :
385 : static inline void
386 469228 : BBPgetfilename(char *s, size_t len, bat i)
387 : {
388 469228 : if (i >= 0100) {
389 446656 : char *p = BBPsubdir_recursive(s, i);
390 446621 : *p++ = DIR_SEP;
391 446621 : len -= (p - s);
392 446621 : s = p;
393 : }
394 469193 : if (snprintf(s, len, "%o", i) >= (int) len)
395 0 : TRC_CRITICAL(BAT, "impossible error\n");
396 469193 : }
397 :
398 : static gdk_return BBPrecover(int farmid);
399 : static gdk_return BBPrecover_subdir(void);
400 : static bool BBPdiskscan(const char *, size_t);
401 :
402 : static int
403 9358 : vheapinit(BAT *b, const char *buf, unsigned bbpversion, const char *filename, int lineno)
404 : {
405 9358 : int n = 0;
406 9358 : uint64_t free, size;
407 9358 : uint16_t storage;
408 :
409 9358 : (void) bbpversion; /* could be used to implement compatibility */
410 :
411 9358 : size = 0; /* for GDKLIBRARY_HSIZE case */
412 9358 : storage = STORE_INVALID; /* for GDKLIBRARY_HSIZE case */
413 18716 : if (bbpversion <= GDKLIBRARY_HSIZE ?
414 0 : sscanf(buf,
415 : " %" SCNu64 " %" SCNu64 " %" SCNu16
416 : "%n",
417 : &free, &size, &storage, &n) < 3 :
418 9358 : sscanf(buf,
419 : " %" SCNu64
420 : "%n",
421 : &free, &n) < 1) {
422 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d", lineno);
423 0 : return -1;
424 : }
425 9358 : if (b->batCount == 0)
426 2606 : free = 0;
427 9358 : if (b->ttype >= 0 &&
428 9144 : ATOMstorage(b->ttype) == TYPE_str &&
429 9090 : free < GDK_STRHASHTABLE * sizeof(stridx_t) + BATTINY * GDK_VARALIGN)
430 7811 : size = GDK_STRHASHTABLE * sizeof(stridx_t) + BATTINY * GDK_VARALIGN;
431 1547 : else if (free < 512)
432 132 : size = 512;
433 : else
434 1415 : size = free;
435 18716 : *b->tvheap = (Heap) {
436 9358 : .free = (size_t) free,
437 9358 : .size = (size_t) size,
438 : .base = NULL,
439 : .storage = STORE_INVALID,
440 : .cleanhash = true,
441 : .newstorage = STORE_INVALID,
442 : .dirty = false,
443 9358 : .parentid = b->batCacheid,
444 9358 : .farmid = BBPselectfarm(PERSISTENT, b->ttype, varheap),
445 9358 : .hasfile = free > 0,
446 : };
447 9358 : strconcat_len(b->tvheap->filename, sizeof(b->tvheap->filename),
448 : filename, ".theap", NULL);
449 9358 : return n;
450 : }
451 :
452 : static int
453 35163 : heapinit(BAT *b, const char *buf,
454 : #ifdef GDKLIBRARY_HASHASH
455 : int *hashash,
456 : #endif
457 : unsigned bbpversion, const char *filename, int lineno)
458 : {
459 35163 : int t;
460 35163 : char type[33];
461 35163 : uint16_t width;
462 35163 : uint16_t var;
463 35163 : uint16_t properties;
464 35163 : uint64_t nokey0;
465 35163 : uint64_t nokey1;
466 35163 : uint64_t nosorted;
467 35163 : uint64_t norevsorted;
468 35163 : uint64_t base;
469 35163 : uint64_t free;
470 35163 : uint64_t size;
471 35163 : uint16_t storage;
472 35163 : uint64_t minpos, maxpos;
473 35163 : int n;
474 :
475 35163 : (void) bbpversion; /* could be used to implement compatibility */
476 :
477 35163 : size = 0; /* for GDKLIBRARY_HSIZE case */
478 35163 : storage = STORE_INVALID; /* for GDKLIBRARY_HSIZE case */
479 70326 : if (bbpversion <= GDKLIBRARY_HSIZE ?
480 0 : sscanf(buf,
481 : " %10s %" SCNu16 " %" SCNu16 " %" SCNu16 " %" SCNu64
482 : " %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64
483 : " %" SCNu64 " %" SCNu64 " %" SCNu16 " %" SCNu64 " %" SCNu64
484 : "%n",
485 : type, &width, &var, &properties, &nokey0,
486 : &nokey1, &nosorted, &norevsorted, &base,
487 : &free, &size, &storage, &minpos, &maxpos,
488 : &n) < 14 :
489 35163 : sscanf(buf,
490 : " %10s %" SCNu16 " %" SCNu16 " %" SCNu16 " %" SCNu64
491 : " %" SCNu64 " %" SCNu64 " %" SCNu64 " %" SCNu64
492 : " %" SCNu64 " %" SCNu64 " %" SCNu64
493 : "%n",
494 : type, &width, &var, &properties, &nokey0,
495 : &nokey1, &nosorted, &norevsorted, &base,
496 : &free, &minpos, &maxpos,
497 : &n) < 12) {
498 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d", lineno);
499 0 : return -1;
500 : }
501 :
502 35163 : if (strcmp(type, "wkba") == 0) {
503 0 : TRC_CRITICAL(GDK, "type wkba (SQL name: GeometryA) has been removed\n");
504 0 : return -1;
505 : }
506 : #ifdef HAVE_GEOM
507 : #if GDKLIBRARY <= 061050U
508 35163 : if (strcmp(type, "wkb") == 0) {
509 : /* don't trust properties having to do with ordering of
510 : * type wkb because of a bug in the wkbCOMP
511 : * implementation; this was fixed during the lifetime of
512 : * BBP version 061050 */
513 204 : minpos = maxpos = oid_nil;
514 204 : nosorted = norevsorted = 0;
515 204 : properties &= ~0x0081;
516 : }
517 : #endif
518 : #endif
519 :
520 35163 : if (properties & ~0x1F81) {
521 0 : TRC_CRITICAL(GDK, "unknown properties are set: incompatible database on line %d of BBP.dir\n", lineno);
522 0 : return -1;
523 : }
524 : #ifdef GDKLIBRARY_HASHASH
525 35163 : *hashash = var & 2;
526 : #endif
527 35163 : var &= ~2;
528 35163 : if ((t = ATOMindex(type)) < 0) {
529 241 : if ((t = ATOMunknown_find(type)) == 0) {
530 0 : TRC_CRITICAL(GDK, "no space for atom %s", type);
531 0 : return -1;
532 : }
533 44066 : } else if (var != (t == TYPE_void || BATatoms[t].atomPut != NULL)) {
534 0 : TRC_CRITICAL(GDK, "inconsistent entry in BBP.dir: tvarsized mismatch for BAT %d on line %d\n", (int) b->batCacheid, lineno);
535 0 : return -1;
536 34922 : } else if (var && t != 0 ?
537 9144 : ATOMsize(t) < width ||
538 9144 : (width != 1 && width != 2 && width != 4
539 : #if SIZEOF_VAR_T == 8
540 54 : && width != 8
541 : #endif
542 : ) :
543 25778 : ATOMsize(t) != width) {
544 0 : TRC_CRITICAL(GDK, "inconsistent entry in BBP.dir: tsize mismatch for BAT %d on line %d\n", (int) b->batCacheid, lineno);
545 0 : return -1;
546 : }
547 35163 : b->ttype = t;
548 35163 : b->twidth = width;
549 35163 : b->tshift = ATOMelmshift(width);
550 35163 : assert_shift_width(b->tshift,b->twidth);
551 35163 : b->tnokey[0] = (BUN) nokey0;
552 35163 : b->tnokey[1] = (BUN) nokey1;
553 35163 : b->tsorted = (bit) ((properties & 0x0001) != 0);
554 35163 : b->trevsorted = (bit) ((properties & 0x0080) != 0);
555 35163 : b->tkey = (properties & 0x0100) != 0;
556 35163 : b->tnonil = (properties & 0x0400) != 0;
557 35163 : b->tnil = (properties & 0x0800) != 0;
558 35163 : b->tascii = (properties & 0x1000) != 0;
559 35163 : b->tnosorted = (BUN) nosorted;
560 35163 : b->tnorevsorted = (BUN) norevsorted;
561 35163 : b->tunique_est = 0.0;
562 : /* (properties & 0x0200) is the old tdense flag */
563 35163 : b->tseqbase = (properties & 0x0200) == 0 || base >= (uint64_t) oid_nil ? oid_nil : (oid) base;
564 35163 : b->theap->free = (size_t) free;
565 35163 : b->theap->hasfile = free > 0;
566 : /* set heap size to match capacity */
567 35163 : if (b->ttype == TYPE_msk) {
568 : /* round up capacity to multiple of 32 */
569 5454 : b->batCapacity = (b->batCapacity + 31) & ~((BUN) 31);
570 5454 : b->theap->size = b->batCapacity / 8;
571 : } else {
572 29709 : b->theap->size = (size_t) b->batCapacity << b->tshift;
573 : }
574 35163 : b->theap->base = NULL;
575 35163 : settailname(b->theap, filename, t, width);
576 35163 : b->theap->storage = STORE_INVALID;
577 35163 : b->theap->newstorage = STORE_INVALID;
578 35163 : b->theap->farmid = BBPselectfarm(PERSISTENT, b->ttype, offheap);
579 35163 : b->theap->dirty = false;
580 35163 : b->theap->parentid = b->batCacheid;
581 35163 : if (minpos < b->batCount)
582 13188 : b->tminpos = (BUN) minpos;
583 : else
584 21975 : b->tminpos = BUN_NONE;
585 35163 : if (maxpos < b->batCount)
586 13238 : b->tmaxpos = (BUN) maxpos;
587 : else
588 21925 : b->tmaxpos = BUN_NONE;
589 35163 : if (t && var) {
590 9358 : t = vheapinit(b, buf + n, bbpversion, filename, lineno);
591 9358 : if (t < 0)
592 : return t;
593 9358 : n += t;
594 : } else {
595 25805 : b->tvheap = NULL;
596 : }
597 35163 : return n;
598 : }
599 :
600 : /* read a single line from the BBP.dir file (file pointer fp) and fill
601 : * in the structure pointed to by bn and extra information through the
602 : * other pointers; this function does not allocate any memory; return 0
603 : * on end of file, 1 on success, and -1 on failure */
604 : /* set to true during initialization, else always false; if false, do
605 : * not return any options (set pointer to NULL as if there aren't any);
606 : * if true and there are options, return them in freshly allocated
607 : * memory through *options */
608 : static bool return_options = false;
609 : int
610 35524 : BBPreadBBPline(FILE *fp, unsigned bbpversion, int *lineno, BAT *bn,
611 : #ifdef GDKLIBRARY_HASHASH
612 : int *hashash,
613 : #endif
614 : char *batname, char *filename, char **options)
615 : {
616 35524 : char buf[4096];
617 35524 : uint64_t batid;
618 35524 : unsigned int properties;
619 35524 : int nread, n;
620 35524 : char *s;
621 35524 : uint64_t count, base = 0;
622 :
623 35524 : if (fgets(buf, sizeof(buf), fp) == NULL) {
624 361 : if (ferror(fp)) {
625 0 : TRC_CRITICAL(GDK, "error reading BBP.dir on line %d\n", *lineno);
626 0 : return -1;
627 : }
628 : return 0; /* end of file */
629 : }
630 35163 : (*lineno)++;
631 35163 : if ((s = strpbrk(buf, "\r\n")) != NULL) {
632 35163 : if (s[0] == '\r' && s[1] != '\n') {
633 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d", *lineno);
634 0 : return -1;
635 : }
636 : /* zap the newline */
637 35163 : *s = '\0';
638 : } else {
639 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d: line too long\n", *lineno);
640 0 : return -1;
641 : }
642 :
643 70326 : if (bbpversion <= GDKLIBRARY_HSIZE ?
644 0 : sscanf(buf,
645 : "%" SCNu64 " %*u %128s %*s %u %" SCNu64 " %*u %" SCNu64
646 : "%n",
647 : &batid, batname,
648 : &properties, &count, &base,
649 : &nread) < 5 :
650 : bbpversion <= GDKLIBRARY_STATUS ?
651 2534 : sscanf(buf,
652 : "%" SCNu64 " %*u %128s %*s %u %" SCNu64 " %" SCNu64
653 : "%n",
654 : &batid, batname,
655 : &properties, &count, &base,
656 : &nread) < 5 :
657 32629 : sscanf(buf,
658 : "%" SCNu64 " %128s %u %" SCNu64 " %" SCNu64
659 : "%n",
660 : &batid, batname,
661 : &properties, &count, &base,
662 : &nread) < 5) {
663 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d", *lineno);
664 0 : return -1;
665 : }
666 :
667 35163 : if (batid >= N_BBPINIT * BBPINIT) {
668 0 : TRC_CRITICAL(GDK, "bat ID (%" PRIu64 ") too large to accommodate (max %d), on line %d.", batid, N_BBPINIT * BBPINIT - 1, *lineno);
669 0 : return -1;
670 : }
671 :
672 35163 : BBPgetfilename(filename, sizeof(BBP_physical(0)), (bat) batid);
673 :
674 35163 : bn->batCacheid = (bat) batid;
675 35163 : bn->batTransient = false;
676 35163 : bn->batCopiedtodisk = true;
677 35163 : switch ((properties & 0x06) >> 1) {
678 780 : case 0:
679 780 : bn->batRestricted = BAT_WRITE;
680 780 : break;
681 34383 : case 1:
682 34383 : bn->batRestricted = BAT_READ;
683 34383 : break;
684 0 : case 2:
685 0 : bn->batRestricted = BAT_APPEND;
686 0 : break;
687 0 : default:
688 0 : TRC_CRITICAL(GDK, "incorrect batRestricted value");
689 0 : return -1;
690 : }
691 35163 : bn->batCount = (BUN) count;
692 35163 : bn->batInserted = bn->batCount;
693 : /* set capacity to at least count */
694 35163 : bn->batCapacity = (BUN) count <= BATTINY ? BATTINY : (BUN) count;
695 :
696 35163 : if (base > (uint64_t) GDK_oid_max) {
697 0 : TRC_CRITICAL(GDK, "head seqbase out of range (ID = %" PRIu64 ", seq = %" PRIu64 ") on line %d.", batid, base, *lineno);
698 0 : return -1;
699 : }
700 35163 : bn->hseqbase = (oid) base;
701 35163 : n = heapinit(bn, buf + nread,
702 : #ifdef GDKLIBRARY_HASHASH
703 : hashash,
704 : #endif
705 : bbpversion, filename, *lineno);
706 35163 : if (n < 0) {
707 : return -1;
708 : }
709 35163 : nread += n;
710 :
711 35163 : if (nread >= (int) sizeof(buf) || (buf[nread] != '\0' && buf[nread] != ' ')) {
712 0 : TRC_CRITICAL(GDK, "invalid format for BBP.dir on line %d", *lineno);
713 0 : return -1;
714 : }
715 35163 : if (options) {
716 35163 : if (return_options && buf[nread] == ' ') {
717 0 : if ((*options = GDKstrdup(buf + nread + 1)) == NULL) {
718 0 : TRC_CRITICAL(GDK, "GDKstrdup failed\n");
719 0 : return -1;
720 : }
721 : } else {
722 35163 : *options = NULL;
723 : }
724 : }
725 : return 1;
726 : }
727 :
728 : static gdk_return
729 356 : BBPreadEntries(FILE *fp, unsigned bbpversion, int lineno
730 : #ifdef GDKLIBRARY_HASHASH
731 : , bat **hashbats, bat *nhashbats
732 : #endif
733 : )
734 : {
735 : #ifdef GDKLIBRARY_HASHASH
736 356 : bat *hbats = NULL;
737 356 : bat nhbats = 0;
738 : #endif
739 :
740 : /* read the BBP.dir and insert the BATs into the BBP */
741 356 : return_options = true;
742 356 : MT_lock_set(&BBPnameLock);
743 33898 : for (;;) {
744 34254 : BAT b;
745 34254 : Heap h;
746 34254 : Heap vh;
747 34254 : vh = h = (Heap) {
748 : .free = 0,
749 : };
750 34254 : b = (BAT) {
751 : .theap = &h,
752 : .tvheap = &vh,
753 : };
754 34254 : char *options;
755 34254 : char headname[129];
756 34254 : char filename[sizeof(BBP_physical(0))];
757 34254 : char logical[1024];
758 : #ifdef GDKLIBRARY_HASHASH
759 34254 : int Thashash;
760 : #endif
761 :
762 34254 : switch (BBPreadBBPline(fp, bbpversion, &lineno, &b,
763 : #ifdef GDKLIBRARY_HASHASH
764 : &Thashash,
765 : #endif
766 : headname, filename, &options)) {
767 356 : case 0:
768 : /* end of file */
769 : #ifdef GDKLIBRARY_HASHASH
770 356 : *hashbats = hbats;
771 356 : *nhashbats = nhbats;
772 : #endif
773 356 : return_options = false;
774 356 : MT_lock_unset(&BBPnameLock);
775 356 : return GDK_SUCCEED;
776 : case 1:
777 : /* successfully read an entry */
778 33898 : break;
779 0 : default:
780 : /* error */
781 0 : goto bailout;
782 : }
783 :
784 33898 : if (b.batCacheid >= N_BBPINIT * BBPINIT) {
785 0 : GDKfree(options);
786 0 : TRC_CRITICAL(GDK, "bat ID (%d) too large to accommodate (max %d), on line %d.", b.batCacheid, N_BBPINIT * BBPINIT - 1, lineno);
787 0 : goto bailout;
788 : }
789 :
790 33898 : if (b.batCacheid >= (bat) ATOMIC_GET(&BBPsize)) {
791 0 : if ((bat) ATOMIC_GET(&BBPsize) + 1 >= BBPlimit &&
792 0 : BBPextend(b.batCacheid + 1) != GDK_SUCCEED) {
793 0 : GDKfree(options);
794 0 : goto bailout;
795 : }
796 0 : ATOMIC_SET(&BBPsize, b.batCacheid + 1);
797 : }
798 33898 : BAT *bn = BBP_desc(b.batCacheid);
799 33898 : if (bn->batCacheid != 0) {
800 0 : GDKfree(options);
801 0 : TRC_CRITICAL(GDK, "duplicate entry in BBP.dir (ID = "
802 : "%d) on line %d.", b.batCacheid, lineno);
803 0 : goto bailout;
804 : }
805 :
806 : #ifdef GDKLIBRARY_HASHASH
807 33898 : if (Thashash) {
808 0 : assert(bbpversion <= GDKLIBRARY_HASHASH);
809 0 : bat *sb = GDKrealloc(hbats, ++nhbats * sizeof(bat));
810 0 : if (sb == NULL) {
811 0 : GDKfree(options);
812 0 : goto bailout;
813 : }
814 0 : hbats = sb;
815 0 : hbats[nhbats - 1] = b.batCacheid;
816 : }
817 : #endif
818 :
819 33898 : Heap *hn;
820 33898 : if ((hn = GDKmalloc(sizeof(Heap))) == NULL) {
821 0 : GDKfree(options);
822 0 : TRC_CRITICAL(GDK, "cannot allocate memory for BAT.");
823 0 : goto bailout;
824 : }
825 33898 : *bn = b;
826 33898 : *hn = h;
827 33898 : bn->theap = hn;
828 33898 : if (b.tvheap) {
829 9018 : Heap *vhn;
830 9018 : assert(b.tvheap == &vh);
831 9018 : if ((vhn = GDKmalloc(sizeof(Heap))) == NULL) {
832 0 : GDKfree(hn);
833 0 : GDKfree(options);
834 0 : TRC_CRITICAL(GDK, "cannot allocate memory for BAT.");
835 0 : goto bailout;
836 : }
837 9018 : *vhn = vh;
838 9018 : bn->tvheap = vhn;
839 9018 : ATOMIC_INIT(&bn->tvheap->refs, 1);
840 : }
841 :
842 33898 : char name[MT_NAME_LEN];
843 33898 : snprintf(name, sizeof(name), "heaplock%d", bn->batCacheid); /* fits */
844 33898 : MT_lock_init(&bn->theaplock, name);
845 33898 : snprintf(name, sizeof(name), "BATlock%d", bn->batCacheid); /* fits */
846 33898 : MT_lock_init(&bn->batIdxLock, name);
847 33898 : snprintf(name, sizeof(name), "hashlock%d", bn->batCacheid); /* fits */
848 33898 : MT_rwlock_init(&bn->thashlock, name);
849 33898 : ATOMIC_INIT(&bn->theap->refs, 1);
850 :
851 33898 : if (snprintf(BBP_bak(b.batCacheid), sizeof(BBP_bak(b.batCacheid)), "tmp_%o", (unsigned) b.batCacheid) >= (int) sizeof(BBP_bak(b.batCacheid))) {
852 0 : BATdestroy(bn);
853 0 : GDKfree(options);
854 0 : TRC_CRITICAL(GDK, "BBP logical filename directory is too large, on line %d\n", lineno);
855 0 : goto bailout;
856 : }
857 33898 : char *s;
858 33898 : if ((s = strchr(headname, '~')) != NULL && s == headname) {
859 : /* sizeof(logical) > sizeof(BBP_bak(b.batCacheid)), so
860 : * this fits */
861 0 : strcpy(logical, BBP_bak(b.batCacheid));
862 : } else {
863 0 : if (s)
864 0 : *s = 0;
865 33898 : strcpy_len(logical, headname, sizeof(logical));
866 : }
867 33898 : if (strcmp(logical, BBP_bak(b.batCacheid)) == 0) {
868 33104 : BBP_logical(b.batCacheid) = BBP_bak(b.batCacheid);
869 : } else {
870 794 : BBP_logical(b.batCacheid) = GDKstrdup(logical);
871 794 : if (BBP_logical(b.batCacheid) == NULL) {
872 0 : BATdestroy(bn);
873 0 : GDKfree(options);
874 0 : TRC_CRITICAL(GDK, "GDKstrdup failed\n");
875 0 : goto bailout;
876 : }
877 : }
878 33898 : strcpy_len(BBP_physical(b.batCacheid), filename, sizeof(BBP_physical(b.batCacheid)));
879 : #ifdef __COVERITY__
880 : /* help coverity */
881 : BBP_physical(b.batCacheid)[sizeof(BBP_physical(b.batCacheid)) - 1] = 0;
882 : #endif
883 33898 : BBP_options(b.batCacheid) = options;
884 33898 : BBP_refs(b.batCacheid) = 0;
885 33898 : BBP_lrefs(b.batCacheid) = 1; /* any BAT we encounter here is persistent, so has a logical reference */
886 33898 : BBP_pid(b.batCacheid) = 0;
887 33898 : BBP_status_set(b.batCacheid, BBPEXISTING);
888 33898 : if (BBPnamecheck(BBP_logical(b.batCacheid)) == 0)
889 794 : BBP_insert(b.batCacheid);
890 : }
891 :
892 0 : bailout:
893 0 : MT_lock_unset(&BBPnameLock);
894 0 : return_options = false;
895 : #ifdef GDKLIBRARY_HASHASH
896 0 : GDKfree(hbats);
897 : #endif
898 0 : return GDK_FAIL;
899 : }
900 :
901 : /* check that the necessary files for all BATs exist and are large
902 : * enough */
903 : static gdk_return
904 357 : BBPcheckbats(unsigned bbpversion)
905 : {
906 357 : (void) bbpversion;
907 81700 : for (bat bid = 1, size = (bat) ATOMIC_GET(&BBPsize); bid < size; bid++) {
908 81343 : struct stat statb;
909 81343 : BAT *b;
910 81343 : char path[MAXPATH];
911 :
912 81343 : b = BBP_desc(bid);
913 81343 : if (b->batCacheid == 0 || b->ttype == TYPE_void) {
914 : /* no files needed */
915 47445 : continue;
916 : }
917 33898 : if (b->theap->free > 0) {
918 22445 : if (GDKfilepath(path, sizeof(path), 0, BATDIR, b->theap->filename, NULL) != GDK_SUCCEED)
919 0 : return GDK_FAIL;
920 : /* first check string offset heap with width,
921 : * then without */
922 22445 : if (MT_stat(path, &statb) < 0) {
923 0 : GDKsyserror("cannot stat file %s (expected size %zu)\n",
924 : path, b->theap->free);
925 0 : return GDK_FAIL;
926 : }
927 22445 : if ((size_t) statb.st_size < b->theap->free) {
928 0 : GDKerror("file %s too small (expected %zu, actual %zu)\n", path, b->theap->free, (size_t) statb.st_size);
929 0 : return GDK_FAIL;
930 : }
931 22445 : size_t hfree = b->theap->free;
932 22445 : hfree = (hfree + GDK_mmap_pagesize - 1) & ~(GDK_mmap_pagesize - 1);
933 22445 : if (hfree == 0)
934 0 : hfree = GDK_mmap_pagesize;
935 22445 : if (statb.st_size > (off_t) hfree) {
936 9 : int fd;
937 9 : if ((fd = MT_open(path, O_RDWR | O_CLOEXEC | O_BINARY)) >= 0) {
938 9 : if (ftruncate(fd, hfree) == -1)
939 0 : perror("ftruncate");
940 9 : (void) close(fd);
941 : }
942 : }
943 : }
944 33898 : if (b->tvheap != NULL && b->tvheap->free > 0) {
945 6517 : if (GDKfilepath(path, sizeof(path), 0, BATDIR, BBP_physical(b->batCacheid), "theap") != GDK_SUCCEED)
946 : return GDK_FAIL;
947 6517 : if (MT_stat(path, &statb) < 0) {
948 0 : GDKsyserror("cannot stat file %s\n",
949 : path);
950 0 : return GDK_FAIL;
951 : }
952 6517 : if ((size_t) statb.st_size < b->tvheap->free) {
953 0 : GDKerror("file %s too small (expected %zu, actual %zu)\n", path, b->tvheap->free, (size_t) statb.st_size);
954 0 : return GDK_FAIL;
955 : }
956 6517 : size_t hfree = b->tvheap->free;
957 6517 : hfree = (hfree + GDK_mmap_pagesize - 1) & ~(GDK_mmap_pagesize - 1);
958 6517 : if (hfree == 0)
959 0 : hfree = GDK_mmap_pagesize;
960 6517 : if (statb.st_size > (off_t) hfree) {
961 8 : int fd;
962 8 : if ((fd = MT_open(path, O_RDWR | O_CLOEXEC | O_BINARY)) >= 0) {
963 8 : if (ftruncate(fd, hfree) == -1)
964 0 : perror("ftruncate");
965 8 : (void) close(fd);
966 : }
967 : }
968 : }
969 : }
970 : return GDK_SUCCEED;
971 : }
972 :
973 : #ifdef HAVE_HGE
974 : #define SIZEOF_MAX_INT SIZEOF_HGE
975 : #else
976 : #define SIZEOF_MAX_INT SIZEOF_LNG
977 : #endif
978 :
979 : unsigned
980 361 : BBPheader(FILE *fp, int *lineno, bat *bbpsize, lng *logno, bool allow_hge_upgrade)
981 : {
982 361 : char buf[BUFSIZ];
983 361 : int sz, ptrsize, oidsize, intsize;
984 361 : unsigned bbpversion;
985 :
986 361 : if (fgets(buf, sizeof(buf), fp) == NULL) {
987 0 : TRC_CRITICAL(GDK, "BBP.dir is empty");
988 0 : return 0;
989 : }
990 361 : ++*lineno;
991 361 : if (sscanf(buf, "BBP.dir, GDKversion %u\n", &bbpversion) != 1) {
992 0 : GDKerror("old BBP without version number; "
993 : "dump the database using a compatible version, "
994 : "then restore into new database using this version.\n");
995 0 : return 0;
996 : }
997 361 : if (bbpversion != GDKLIBRARY &&
998 : bbpversion != GDKLIBRARY_STATUS &&
999 : bbpversion != GDKLIBRARY_JSON &&
1000 361 : bbpversion != GDKLIBRARY_HSIZE &&
1001 : bbpversion != GDKLIBRARY_HASHASH) {
1002 0 : TRC_CRITICAL(GDK, "incompatible BBP version: expected 0%o, got 0%o. "
1003 : "This database was probably created by a %s version of MonetDB.",
1004 : GDKLIBRARY, bbpversion,
1005 : bbpversion > GDKLIBRARY ? "newer" : "too old");
1006 0 : return 0;
1007 : }
1008 361 : if (fgets(buf, sizeof(buf), fp) == NULL) {
1009 0 : TRC_CRITICAL(GDK, "short BBP");
1010 0 : return 0;
1011 : }
1012 361 : ++*lineno;
1013 361 : if (sscanf(buf, "%d %d %d", &ptrsize, &oidsize, &intsize) != 3) {
1014 0 : TRC_CRITICAL(GDK, "BBP.dir has incompatible format: pointer, OID, and max. integer sizes are missing on line %d", *lineno);
1015 0 : return 0;
1016 : }
1017 361 : if (ptrsize != SIZEOF_SIZE_T || oidsize != SIZEOF_OID) {
1018 0 : TRC_CRITICAL(GDK, "database created with incompatible server: "
1019 : "expected pointer size %d, got %d, expected OID size %d, got %d.",
1020 : SIZEOF_SIZE_T, ptrsize, SIZEOF_OID, oidsize);
1021 0 : return 0;
1022 : }
1023 361 : if (intsize > SIZEOF_MAX_INT) {
1024 0 : TRC_CRITICAL(GDK, "database created with incompatible server: "
1025 : "expected max. integer size %d, got %d.",
1026 : SIZEOF_MAX_INT, intsize);
1027 0 : return 0;
1028 : }
1029 361 : if (intsize < SIZEOF_MAX_INT && !allow_hge_upgrade) {
1030 0 : TRC_CRITICAL(GDK, "database created with incompatible server: "
1031 : "expected max. integer size %d, got %d; "
1032 : "use --set allow_hge_upgrade=yes to upgrade.",
1033 : SIZEOF_MAX_INT, intsize);
1034 0 : return 0;
1035 : }
1036 361 : if (fgets(buf, sizeof(buf), fp) == NULL) {
1037 0 : TRC_CRITICAL(GDK, "short BBP");
1038 0 : return 0;
1039 : }
1040 361 : ++*lineno;
1041 361 : if (sscanf(buf, "BBPsize=%d", &sz) != 1) {
1042 0 : TRC_CRITICAL(GDK, "no BBPsize value found\n");
1043 0 : return 0;
1044 : }
1045 361 : if (sz > *bbpsize)
1046 132 : *bbpsize = sz;
1047 361 : if (fgets(buf, sizeof(buf), fp) == NULL) {
1048 0 : TRC_CRITICAL(GDK, "short BBP");
1049 0 : return 0;
1050 : }
1051 722 : if (bbpversion <= GDKLIBRARY_STATUS ?
1052 8 : sscanf(buf, "BBPinfo=" LLSCN " %*d", logno) != 1 :
1053 353 : sscanf(buf, "BBPinfo=" LLSCN, logno) != 1) {
1054 0 : TRC_CRITICAL(GDK, "no info value found\n");
1055 0 : return 0;
1056 : }
1057 361 : return bbpversion;
1058 : }
1059 :
1060 : bool
1061 81393714 : GDKinmemory(int farmid)
1062 : {
1063 81393714 : if (farmid == NOFARM)
1064 : farmid = 0;
1065 80073148 : assert(farmid >= 0 && farmid < MAXFARMS);
1066 81393714 : return BBPfarms[farmid].dirname == NULL;
1067 : }
1068 :
1069 : /* all errors are fatal */
1070 : gdk_return
1071 1065 : BBPaddfarm(const char *dirname, uint32_t rolemask, bool logerror)
1072 : {
1073 1065 : struct stat st;
1074 1065 : int i;
1075 :
1076 1065 : if (dirname == NULL) {
1077 1 : assert(BBPfarms[0].dirname == NULL);
1078 1 : assert(rolemask & 1);
1079 1 : assert(BBPfarms[0].roles == 0);
1080 1 : BBPfarms[0].roles = rolemask;
1081 1 : return GDK_SUCCEED;
1082 : }
1083 1064 : if (strchr(dirname, '\n') != NULL) {
1084 0 : if (logerror)
1085 0 : GDKerror("no newline allowed in directory name\n");
1086 0 : return GDK_FAIL;
1087 : }
1088 1064 : if (rolemask == 0 || (rolemask & 1 && BBPfarms[0].roles != 0)) {
1089 0 : if (logerror)
1090 0 : GDKerror("bad rolemask\n");
1091 0 : return GDK_FAIL;
1092 : }
1093 1064 : if (strcmp(dirname, "in-memory") == 0 ||
1094 1063 : /* backward compatibility: */ strcmp(dirname, ":memory:") == 0) {
1095 : dirname = NULL;
1096 1063 : } else if (MT_mkdir(dirname) < 0) {
1097 975 : if (errno == EEXIST) {
1098 975 : if (MT_stat(dirname, &st) == -1 || !S_ISDIR(st.st_mode)) {
1099 0 : if (logerror)
1100 0 : GDKerror("%s: not a directory\n", dirname);
1101 0 : return GDK_FAIL;
1102 : }
1103 : } else {
1104 0 : if (logerror)
1105 0 : GDKsyserror("%s: cannot create directory\n", dirname);
1106 0 : return GDK_FAIL;
1107 : }
1108 : }
1109 2117 : for (i = 0; i < MAXFARMS; i++) {
1110 2117 : if (BBPfarms[i].roles == 0) {
1111 1064 : if (dirname) {
1112 1063 : BBPfarms[i].dirname = GDKstrdup(dirname);
1113 1063 : if (BBPfarms[i].dirname == NULL)
1114 : return GDK_FAIL;
1115 : }
1116 1064 : BBPfarms[i].roles = rolemask;
1117 1064 : if ((rolemask & 1) == 0 && dirname != NULL) {
1118 : char bbpdir[MAXPATH];
1119 : int j;
1120 :
1121 1087 : for (j = 0; j < i; j++)
1122 896 : if (BBPfarms[j].dirname != NULL &&
1123 896 : strcmp(BBPfarms[i].dirname,
1124 : BBPfarms[j].dirname) == 0)
1125 514 : return GDK_SUCCEED;
1126 : /* if an extra farm, make sure we
1127 : * don't find a BBP.dir there that
1128 : * might belong to an existing
1129 : * database */
1130 191 : if (GDKfilepath(bbpdir, sizeof(bbpdir), i, BATDIR, "BBP", "dir") != GDK_SUCCEED) {
1131 : return GDK_FAIL;
1132 : }
1133 191 : if (MT_stat(bbpdir, &st) != -1 || errno != ENOENT) {
1134 0 : if (logerror)
1135 0 : GDKerror("%s is a database\n", dirname);
1136 0 : return GDK_FAIL;
1137 : }
1138 191 : if (GDKfilepath(bbpdir, sizeof(bbpdir), i, BAKDIR, "BBP", "dir") != GDK_SUCCEED) {
1139 : return GDK_FAIL;
1140 : }
1141 191 : if (MT_stat(bbpdir, &st) != -1 || errno != ENOENT) {
1142 0 : if (logerror)
1143 0 : GDKerror("%s is a database\n", dirname);
1144 0 : return GDK_FAIL;
1145 : }
1146 : }
1147 550 : return GDK_SUCCEED;
1148 : }
1149 : }
1150 0 : if (logerror)
1151 0 : GDKerror("too many farms\n");
1152 : return GDK_FAIL;
1153 : }
1154 :
1155 : gdk_return
1156 359 : BBPchkfarms(void)
1157 : {
1158 359 : const char *dir = NULL;
1159 359 : uint32_t rolemask = 0;
1160 359 : if ((BBPfarms[0].roles & 1) == 0) {
1161 0 : GDKerror("Must call BBPaddfarms at least once for persistent data\n");
1162 0 : return GDK_FAIL;
1163 : }
1164 11847 : for (int i = 0; i < MAXFARMS; i++) {
1165 11488 : if (BBPfarms[i].roles != 0) {
1166 706 : dir = BBPfarms[i].dirname;
1167 706 : rolemask |= BBPfarms[i].roles;
1168 : }
1169 : }
1170 359 : if (dir == NULL)
1171 1 : dir = "in-memory";
1172 359 : if ((rolemask & (1U << TRANSIENT)) == 0) {
1173 0 : gdk_return rc = BBPaddfarm(dir, 1U << TRANSIENT, true);
1174 0 : if (rc != GDK_SUCCEED)
1175 : return rc;
1176 : }
1177 359 : if ((rolemask & (1U << SYSTRANS)) == 0) {
1178 359 : gdk_return rc = BBPaddfarm(dir, 1U << SYSTRANS, true);
1179 359 : if (rc != GDK_SUCCEED)
1180 : return rc;
1181 : }
1182 : return GDK_SUCCEED;
1183 : }
1184 :
1185 : #ifdef GDKLIBRARY_HASHASH
1186 : static gdk_return
1187 0 : fixhashashbat(BAT *b)
1188 : {
1189 0 : const char *nme = BBP_physical(b->batCacheid);
1190 0 : char srcdir[MAXPATH];
1191 :
1192 0 : if (GDKfilepath(srcdir, sizeof(srcdir), NOFARM, BATDIR, nme, NULL) != GDK_SUCCEED) {
1193 0 : TRC_CRITICAL(GDK, "GDKfilepath failed\n");
1194 0 : return GDK_FAIL;
1195 : }
1196 0 : char *s;
1197 0 : if ((s = strrchr(srcdir, DIR_SEP)) != NULL)
1198 0 : *s = 0;
1199 0 : const char *bnme;
1200 0 : if ((bnme = strrchr(nme, DIR_SEP)) != NULL)
1201 0 : bnme++;
1202 : else
1203 : bnme = nme;
1204 0 : long_str filename;
1205 0 : snprintf(filename, sizeof(filename), "BACKUP%c%s", DIR_SEP, bnme);
1206 :
1207 : /* we don't maintain index structures */
1208 0 : HASHdestroy(b);
1209 0 : OIDXdestroy(b);
1210 0 : PROPdestroy(b);
1211 0 : STRMPdestroy(b);
1212 0 : RTREEdestroy(b);
1213 :
1214 : /* make backup of heaps */
1215 0 : const char *t;
1216 0 : if (GDKmove(b->theap->farmid, srcdir, bnme, "tail1",
1217 : BAKDIR, bnme, "tail1", false) == GDK_SUCCEED)
1218 : t = "tail1";
1219 0 : else if (GDKmove(b->theap->farmid, srcdir, bnme, "tail2",
1220 : BAKDIR, bnme, "tail2", false) == GDK_SUCCEED)
1221 : t = "tail2";
1222 : #if SIZEOF_VAR_T == 8
1223 0 : else if (GDKmove(b->theap->farmid, srcdir, bnme, "tail4",
1224 : BAKDIR, bnme, "tail4", false) == GDK_SUCCEED)
1225 : t = "tail4";
1226 : #endif
1227 0 : else if (GDKmove(b->theap->farmid, srcdir, bnme, "tail",
1228 : BAKDIR, bnme, "tail", true) == GDK_SUCCEED)
1229 : t = "tail";
1230 : else {
1231 0 : TRC_CRITICAL(GDK, "cannot make backup of %s.tail\n", nme);
1232 0 : return GDK_FAIL;
1233 : }
1234 0 : GDKclrerr();
1235 0 : if (GDKmove(b->theap->farmid, srcdir, bnme, "theap",
1236 : BAKDIR, bnme, "theap", true) != GDK_SUCCEED) {
1237 0 : TRC_CRITICAL(GDK, "cannot make backup of %s.theap\n", nme);
1238 0 : return GDK_FAIL;
1239 : }
1240 : /* load old heaps */
1241 0 : Heap h1 = *b->theap; /* old heap */
1242 0 : h1.base = NULL;
1243 0 : h1.dirty = false;
1244 0 : strconcat_len(h1.filename, sizeof(h1.filename), filename, ".", t, NULL);
1245 0 : if (HEAPload(&h1, filename, t, false) != GDK_SUCCEED) {
1246 0 : TRC_CRITICAL(GDK, "loading old tail heap "
1247 : "for BAT %d failed\n", b->batCacheid);
1248 0 : return GDK_FAIL;
1249 : }
1250 0 : Heap vh1 = *b->tvheap; /* old heap */
1251 0 : vh1.base = NULL;
1252 0 : vh1.dirty = false;
1253 0 : strconcat_len(vh1.filename, sizeof(vh1.filename), filename, ".theap", NULL);
1254 0 : if (HEAPload(&vh1, filename, "theap", false) != GDK_SUCCEED) {
1255 0 : HEAPfree(&h1, false);
1256 0 : TRC_CRITICAL(GDK, "loading old string heap "
1257 : "for BAT %d failed\n", b->batCacheid);
1258 0 : return GDK_FAIL;
1259 : }
1260 :
1261 : /* create new heaps */
1262 0 : Heap *h2 = GDKmalloc(sizeof(Heap));
1263 0 : Heap *vh2 = GDKmalloc(sizeof(Heap));
1264 0 : if (h2 == NULL || vh2 == NULL) {
1265 0 : GDKfree(h2);
1266 0 : GDKfree(vh2);
1267 0 : HEAPfree(&h1, false);
1268 0 : HEAPfree(&vh1, false);
1269 0 : TRC_CRITICAL(GDK, "allocating new heaps "
1270 : "for BAT %d failed\n", b->batCacheid);
1271 0 : return GDK_FAIL;
1272 : }
1273 0 : *h2 = *b->theap;
1274 0 : h2->base = NULL;
1275 0 : if (HEAPalloc(h2, b->batCapacity, b->twidth) != GDK_SUCCEED) {
1276 0 : GDKfree(h2);
1277 0 : GDKfree(vh2);
1278 0 : HEAPfree(&h1, false);
1279 0 : HEAPfree(&vh1, false);
1280 0 : TRC_CRITICAL(GDK, "allocating new tail heap "
1281 : "for BAT %d failed\n", b->batCacheid);
1282 0 : return GDK_FAIL;
1283 : }
1284 0 : h2->dirty = true;
1285 0 : h2->free = h1.free;
1286 :
1287 0 : *vh2 = *b->tvheap;
1288 0 : strconcat_len(vh2->filename, sizeof(vh2->filename), nme, ".theap", NULL);
1289 0 : strHeap(vh2, b->batCapacity);
1290 0 : if (vh2->base == NULL) {
1291 0 : HEAPfree(&h1, false);
1292 0 : HEAPfree(&vh1, false);
1293 0 : HEAPfree(h2, false);
1294 0 : GDKfree(h2);
1295 0 : GDKfree(vh2);
1296 0 : TRC_CRITICAL(GDK, "allocating new string heap "
1297 : "for BAT %d failed\n", b->batCacheid);
1298 0 : return GDK_FAIL;
1299 : }
1300 0 : vh2->dirty = true;
1301 0 : ATOMIC_INIT(&h2->refs, 1);
1302 0 : ATOMIC_INIT(&vh2->refs, 1);
1303 0 : Heap *ovh = b->tvheap;
1304 0 : b->tvheap = vh2;
1305 0 : vh2 = NULL; /* no longer needed */
1306 0 : for (BUN i = 0; i < b->batCount; i++) {
1307 0 : var_t o;
1308 0 : switch (b->twidth) {
1309 0 : case 1:
1310 0 : o = (var_t) ((uint8_t *) h1.base)[i] + GDK_VAROFFSET;
1311 0 : break;
1312 0 : case 2:
1313 0 : o = (var_t) ((uint16_t *) h1.base)[i] + GDK_VAROFFSET;
1314 0 : break;
1315 : #if SIZEOF_VAR_T == 8
1316 0 : case 4:
1317 0 : o = (var_t) ((uint32_t *) h1.base)[i];
1318 0 : break;
1319 : #endif
1320 0 : default:
1321 0 : o = ((var_t *) h1.base)[i];
1322 0 : break;
1323 : }
1324 0 : const char *s = vh1.base + o;
1325 0 : var_t no = strPut(b, &o, s);
1326 0 : if (no == 0) {
1327 0 : HEAPfree(&h1, false);
1328 0 : HEAPfree(&vh1, false);
1329 0 : HEAPdecref(h2, false);
1330 0 : HEAPdecref(b->tvheap, false);
1331 0 : b->tvheap = ovh;
1332 0 : TRC_CRITICAL(GDK, "storing string value "
1333 : "for BAT %d failed\n", b->batCacheid);
1334 0 : return GDK_FAIL;
1335 : }
1336 0 : assert(no >= GDK_VAROFFSET);
1337 0 : switch (b->twidth) {
1338 0 : case 1:
1339 0 : no -= GDK_VAROFFSET;
1340 0 : assert(no <= 0xFF);
1341 0 : ((uint8_t *) h2->base)[i] = (uint8_t) no;
1342 0 : break;
1343 0 : case 2:
1344 0 : no -= GDK_VAROFFSET;
1345 0 : assert(no <= 0xFFFF);
1346 0 : ((uint16_t *) h2->base)[i] = (uint16_t) no;
1347 0 : break;
1348 : #if SIZEOF_VAR_T == 8
1349 0 : case 4:
1350 0 : assert(no <= 0xFFFFFFFF);
1351 0 : ((uint32_t *) h2->base)[i] = (uint32_t) no;
1352 0 : break;
1353 : #endif
1354 0 : default:
1355 0 : ((var_t *) h2->base)[i] = no;
1356 0 : break;
1357 : }
1358 : }
1359 :
1360 : /* cleanup */
1361 0 : HEAPfree(&h1, false);
1362 0 : HEAPfree(&vh1, false);
1363 0 : if (HEAPsave(h2, nme, BATtailname(b), true, h2->free, NULL) != GDK_SUCCEED) {
1364 0 : HEAPdecref(h2, false);
1365 0 : HEAPdecref(b->tvheap, false);
1366 0 : b->tvheap = ovh;
1367 0 : TRC_CRITICAL(GDK, "saving heap failed\n");
1368 0 : return GDK_FAIL;
1369 : }
1370 0 : if (HEAPsave(b->tvheap, nme, "theap", true, b->tvheap->free, &b->theaplock) != GDK_SUCCEED) {
1371 0 : HEAPfree(b->tvheap, false);
1372 0 : b->tvheap = ovh;
1373 0 : TRC_CRITICAL(GDK, "saving string heap failed\n");
1374 0 : return GDK_FAIL;
1375 : }
1376 0 : HEAPdecref(b->theap, false);
1377 0 : b->theap = h2;
1378 0 : HEAPfree(h2, false);
1379 0 : HEAPdecref(ovh, false);
1380 0 : HEAPfree(b->tvheap, false);
1381 0 : return GDK_SUCCEED;
1382 : }
1383 :
1384 : static gdk_return
1385 0 : fixhashash(bat *hashbats, bat nhashbats)
1386 : {
1387 0 : for (bat i = 0; i < nhashbats; i++) {
1388 0 : bat bid = hashbats[i];
1389 0 : BAT *b = BBP_desc(bid);
1390 0 : if (b->batCacheid == 0) {
1391 : /* not a valid BAT (shouldn't happen) */
1392 0 : continue;
1393 : }
1394 0 : if (fixhashashbat(b) != GDK_SUCCEED)
1395 : return GDK_FAIL;
1396 : }
1397 : return GDK_SUCCEED;
1398 : }
1399 : #endif
1400 :
1401 : #ifdef GDKLIBRARY_JSON
1402 : static gdk_return
1403 0 : jsonupgradebat(BAT *b, json_storage_conversion fixJSONStorage)
1404 : {
1405 0 : const char *nme = BBP_physical(b->batCacheid);
1406 0 : char srcdir[MAXPATH];
1407 :
1408 0 : if (GDKfilepath(srcdir, sizeof(srcdir), NOFARM, BATDIR, nme, NULL) != GDK_SUCCEED) {
1409 0 : TRC_CRITICAL(GDK, "GDKfilepath failed\n");
1410 0 : return GDK_FAIL;
1411 : }
1412 :
1413 0 : char *s;
1414 0 : if ((s = strrchr(srcdir, DIR_SEP)) != NULL)
1415 0 : *s = 0;
1416 0 : const char *bnme;
1417 0 : if ((bnme = strrchr(nme, DIR_SEP)) != NULL) {
1418 0 : bnme++;
1419 : } else {
1420 : bnme = nme;
1421 : }
1422 :
1423 0 : long_str filename;
1424 0 : snprintf(filename, sizeof(filename), "BACKUP%c%s", DIR_SEP, bnme);
1425 :
1426 : /* A json column should not normally have any index structures */
1427 0 : HASHdestroy(b);
1428 0 : OIDXdestroy(b);
1429 0 : PROPdestroy(b);
1430 0 : STRMPdestroy(b);
1431 0 : RTREEdestroy(b);
1432 :
1433 : /* backup the current heaps */
1434 0 : if (GDKmove(b->theap->farmid, srcdir, bnme, "tail",
1435 : BAKDIR, bnme, "tail", false) != GDK_SUCCEED) {
1436 0 : TRC_CRITICAL(GDK, "cannot make backup of %s.tail\n", nme);
1437 0 : return GDK_FAIL;
1438 : }
1439 0 : if (GDKmove(b->theap->farmid, srcdir, bnme, "theap",
1440 : BAKDIR, bnme, "theap", true) != GDK_SUCCEED) {
1441 0 : TRC_CRITICAL(GDK, "cannot make backup of %s.theap\n", nme);
1442 0 : return GDK_FAIL;
1443 : }
1444 :
1445 : /* load the old heaps */
1446 0 : Heap h1 = *b->theap;
1447 0 : h1.base = NULL;
1448 0 : h1.dirty = false;
1449 0 : strconcat_len(h1.filename, sizeof(h1.filename), filename, ".tail", NULL);
1450 0 : if (HEAPload(&h1, filename, "tail", false) != GDK_SUCCEED) {
1451 0 : TRC_CRITICAL(GDK, "loading old tail heap "
1452 : "for BAT %d failed\n", b->batCacheid);
1453 0 : return GDK_FAIL;
1454 : }
1455 :
1456 0 : Heap vh1 = *b->tvheap;
1457 0 : vh1.base = NULL;
1458 0 : vh1.dirty = false;
1459 0 : strconcat_len(vh1.filename, sizeof(vh1.filename), filename, ".theap", NULL);
1460 0 : if (HEAPload(&vh1, filename, "theap", false) != GDK_SUCCEED) {
1461 0 : HEAPfree(&h1, false);
1462 0 : TRC_CRITICAL(GDK, "loading old string heap "
1463 : "for BAT %d failed\n", b->batCacheid);
1464 0 : return GDK_FAIL;
1465 : }
1466 :
1467 : /* create the new heaps */
1468 0 : Heap *h2 = GDKmalloc(sizeof(Heap));
1469 0 : Heap *vh2 = GDKmalloc(sizeof(Heap));
1470 0 : if (h2 == NULL || vh2 == NULL) {
1471 0 : GDKfree(h2);
1472 0 : GDKfree(vh2);
1473 0 : HEAPfree(&h1, false);
1474 0 : HEAPfree(&vh1, false);
1475 0 : TRC_CRITICAL(GDK, "allocating new heaps "
1476 : "for BAT %d failed\n", b->batCacheid);
1477 0 : return GDK_FAIL;
1478 : }
1479 0 : *h2 = *b->theap;
1480 0 : h2->base = NULL;
1481 0 : if (HEAPalloc(h2, b->batCapacity, b->twidth) != GDK_SUCCEED) {
1482 0 : GDKfree(h2);
1483 0 : GDKfree(vh2);
1484 0 : HEAPfree(&h1, false);
1485 0 : HEAPfree(&vh1, false);
1486 0 : TRC_CRITICAL(GDK, "allocating new tail heap "
1487 : "for BAT %d failed\n", b->batCacheid);
1488 0 : return GDK_FAIL;
1489 :
1490 : }
1491 0 : h2->dirty = true;
1492 0 : h2->free = h1.free;
1493 :
1494 0 : *vh2 = *b->tvheap;
1495 0 : strconcat_len(vh2->filename, sizeof(vh2->filename), nme, ".theap", NULL);
1496 0 : strHeap(vh2, b->batCapacity);
1497 0 : if (vh2->base == NULL) {
1498 0 : HEAPfree(&h1, false);
1499 0 : HEAPfree(&vh1, false);
1500 0 : HEAPfree(h2, false);
1501 0 : GDKfree(h2);
1502 0 : GDKfree(vh2);
1503 0 : TRC_CRITICAL(GDK, "allocating new string heap "
1504 : "for BAT %d failed\n", b->batCacheid);
1505 0 : return GDK_FAIL;
1506 : }
1507 0 : vh2->dirty = true;
1508 0 : ATOMIC_INIT(&h2->refs, 1);
1509 0 : ATOMIC_INIT(&vh2->refs, 1);
1510 0 : Heap *ovh = b->tvheap;
1511 0 : b->tvheap = vh2;
1512 0 : vh2 = NULL;
1513 :
1514 0 : for (BUN i = 0; i < b->batCount; i++) {
1515 0 : var_t o = ((var_t *) h1.base)[i];
1516 0 : const char *s = vh1.base + o;
1517 0 : char *ns;
1518 0 : if (fixJSONStorage(&ns, &s) != GDK_SUCCEED) {
1519 0 : HEAPfree(&h1, false);
1520 0 : HEAPfree(&vh1, false);
1521 0 : HEAPdecref(h2, false);
1522 0 : HEAPdecref(b->tvheap, false);
1523 0 : b->tvheap = ovh;
1524 0 : TRC_CRITICAL(GDK, "converting value "
1525 : "in BAT %d failed\n", b->batCacheid);
1526 0 : return GDK_FAIL;
1527 : }
1528 0 : var_t no = strPut(b, &o, ns);
1529 0 : GDKfree(ns);
1530 0 : if (no == 0) {
1531 0 : HEAPfree(&h1, false);
1532 0 : HEAPfree(&vh1, false);
1533 0 : HEAPdecref(h2, false);
1534 0 : HEAPdecref(b->tvheap, false);
1535 0 : b->tvheap = ovh;
1536 0 : TRC_CRITICAL(GDK, "storing new value "
1537 : "in BAT %d failed\n", b->batCacheid);
1538 0 : return GDK_FAIL;
1539 :
1540 : }
1541 0 : ((var_t *)h2->base)[i] = no;
1542 : }
1543 :
1544 : /* cleanup */
1545 0 : HEAPfree(&h1, false);
1546 0 : HEAPfree(&vh1, false);
1547 0 : if (HEAPsave(h2, nme, BATtailname(b), true, h2->free, NULL) !=
1548 : GDK_SUCCEED) {
1549 0 : HEAPdecref(h2, false);
1550 0 : HEAPdecref(b->tvheap, false);
1551 0 : b->tvheap = ovh;
1552 0 : TRC_CRITICAL(GDK, "saving heap failed\n");
1553 0 : return GDK_FAIL;
1554 : }
1555 :
1556 0 : if (HEAPsave(b->tvheap, nme, "theap", true, b->tvheap->free,
1557 : &b->theaplock) != GDK_SUCCEED) {
1558 0 : HEAPfree(b->tvheap, false);
1559 0 : b->tvheap = ovh;
1560 0 : TRC_CRITICAL(GDK, "saving string failed\n");
1561 0 : return GDK_FAIL;
1562 : }
1563 :
1564 0 : HEAPdecref(b->theap, false);
1565 0 : b->theap = h2;
1566 0 : HEAPfree(h2, false);
1567 0 : HEAPdecref(ovh, false);
1568 0 : HEAPfree(b->tvheap, false);
1569 :
1570 0 : return GDK_SUCCEED;
1571 : }
1572 :
1573 : gdk_return
1574 0 : BBPjson_upgrade(json_storage_conversion fixJSONStorage)
1575 : {
1576 0 : bat bid;
1577 0 : int JSON_type = ATOMindex("json");
1578 0 : bat nbat = (bat) ATOMIC_GET(&BBPsize);
1579 0 : bat *upd = GDKmalloc(sizeof(bat) * (size_t) nbat);
1580 0 : int nupd = 0;
1581 :
1582 0 : if (upd == NULL) {
1583 0 : TRC_CRITICAL(GDK, "could not create bat\n");
1584 0 : return GDK_FAIL;
1585 : }
1586 0 : upd[nupd++] = 0; /* first entry unused */
1587 :
1588 0 : BBPlock();
1589 :
1590 0 : for (bid = 1; bid < nbat; bid++) {
1591 0 : BAT *b = BBP_desc(bid);
1592 0 : if (b->batCacheid == 0) {
1593 : /* not a valid BAT */
1594 0 : continue;
1595 : }
1596 :
1597 0 : if (b->ttype < 0) {
1598 0 : const char *nme;
1599 :
1600 0 : nme = ATOMunknown_name(b->ttype);
1601 0 : int tt = ATOMindex(nme);
1602 0 : if (tt >= 0)
1603 0 : b->ttype = tt;
1604 0 : if (strcmp(nme, "json") != 0)
1605 0 : continue;
1606 0 : } else if (b->ttype != JSON_type) {
1607 0 : continue;
1608 : }
1609 0 : fprintf(stderr, "Upgrading json bat %d\n", bid);
1610 0 : if (jsonupgradebat(b, fixJSONStorage) != GDK_SUCCEED) {
1611 0 : BBPunlock();
1612 0 : GDKfree(upd);
1613 0 : return GDK_FAIL;
1614 : }
1615 0 : upd[nupd++] = bid;
1616 : }
1617 0 : BBPunlock();
1618 0 : if (nupd > 1 &&
1619 0 : TMsubcommit_list(upd, NULL, nupd, -1) != GDK_SUCCEED) {
1620 0 : TRC_CRITICAL(GDK, "failed to commit changes\n");
1621 0 : GDKfree(upd);
1622 0 : return GDK_FAIL;
1623 : }
1624 0 : GDKfree(upd);
1625 0 : return GDK_SUCCEED;
1626 : }
1627 : #endif
1628 :
1629 : static bool
1630 116 : BBPtrim(bool aggressive, bat nbat)
1631 : {
1632 116 : int n = 0;
1633 116 : int waitctr = 0;
1634 116 : bool changed = false;
1635 116 : unsigned flag = BBPUNLOADING | BBPSYNCING | BBPSAVING;
1636 116 : if (!aggressive)
1637 116 : flag |= BBPHOT;
1638 116 : lng t0 = GDKusec();
1639 166256 : for (bat bid = 1; bid < nbat && !GDKexiting(); bid++) {
1640 : /* quick check to see if we might possibly have to do
1641 : * work (includes free bats) */
1642 166140 : if ((BBP_status(bid) & BBPLOADED) == 0)
1643 54910 : continue;
1644 : /* don't do this during a (sub)commit */
1645 111230 : BBPtmlock();
1646 111230 : MT_lock_set(&GDKswapLock(bid));
1647 111230 : BAT *b = NULL;
1648 111230 : bool swap = false;
1649 111230 : if ((BBP_status(bid) & (flag | BBPLOADED)) == BBPLOADED &&
1650 23515 : BBP_refs(bid) == 0 &&
1651 23515 : BBP_lrefs(bid) != 0 &&
1652 23515 : (b = BBP_desc(bid))->batCacheid != 0) {
1653 23515 : MT_lock_set(&b->theaplock);
1654 23515 : if (!BATshared(b) &&
1655 23509 : !isVIEW(b) &&
1656 23379 : (!BATdirty(b) ||
1657 0 : (aggressive &&
1658 0 : b->theap->storage == STORE_MMAP &&
1659 0 : (b->tvheap == NULL ||
1660 0 : b->tvheap->storage == STORE_MMAP)) ||
1661 19310 : (b->batRole == PERSISTENT &&
1662 18990 : BBP_lrefs(bid) <= 2))) {
1663 12279 : BBP_status_on(bid, BBPUNLOADING);
1664 12279 : swap = true;
1665 20489 : waitctr += BATdirty(b) ? 9 : 1;
1666 : }
1667 23515 : MT_lock_unset(&b->theaplock);
1668 : }
1669 111230 : MT_lock_unset(&GDKswapLock(bid));
1670 111230 : if (swap) {
1671 12279 : TRC_DEBUG(BAT, "unload and free bat %d\n", bid);
1672 12279 : if (BBPfree(b) != GDK_SUCCEED)
1673 0 : GDKerror("unload failed for bat %d", bid);
1674 12279 : n++;
1675 12279 : changed = true;
1676 : }
1677 111230 : BBPtmunlock();
1678 : /* every once in a while, give others a chance */
1679 111230 : if (++waitctr >= 1000) {
1680 148 : waitctr = 0;
1681 148 : MT_sleep_ms(2);
1682 : }
1683 : }
1684 116 : if (n > 0)
1685 48 : TRC_INFO(BAT, "unloaded %d bats in "LLFMT" usec%s\n", n, GDKusec() - t0, aggressive ? " (also hot)" : "");
1686 116 : return changed;
1687 : }
1688 :
1689 : static void
1690 356 : BBPmanager(void *dummy)
1691 : {
1692 356 : (void) dummy;
1693 356 : bool changed = true;
1694 :
1695 472 : for (;;) {
1696 472 : int n = 0;
1697 472 : bat nbat = (bat) ATOMIC_GET(&BBPsize);
1698 472 : MT_thread_setworking("clearing HOT bits");
1699 359875 : for (bat bid = 1; bid < nbat; bid++) {
1700 359403 : MT_lock_set(&GDKswapLock(bid));
1701 359403 : if (BBP_refs(bid) == 0 && BBP_lrefs(bid) != 0) {
1702 133626 : n += (BBP_status(bid) & BBPHOT) != 0;
1703 133626 : BBP_status_off(bid, BBPHOT);
1704 : }
1705 359403 : MT_lock_unset(&GDKswapLock(bid));
1706 : }
1707 472 : TRC_DEBUG(BAT, "cleared HOT bit from %d bats\n", n);
1708 472 : size_t cur = GDKvm_cursize();
1709 472 : MT_thread_setworking("sleeping");
1710 21076 : for (int i = 0, n = changed && cur > GDK_vm_maxsize / 2 ? 1 : cur > GDK_vm_maxsize / 4 ? 10 : 100; i < n; i++) {
1711 20488 : MT_sleep_ms(100);
1712 20486 : if (GDKexiting())
1713 : return;
1714 : }
1715 116 : MT_thread_setworking("BBPtrim");
1716 116 : changed = BBPtrim(false, nbat);
1717 116 : MT_thread_setworking("BBPcallbacks");
1718 116 : BBPcallbacks();
1719 116 : if (GDKexiting())
1720 : return;
1721 : }
1722 : }
1723 :
1724 : static MT_Id manager;
1725 :
1726 : gdk_return
1727 357 : BBPinit(bool allow_hge_upgrade, bool no_manager)
1728 : {
1729 357 : FILE *fp = NULL;
1730 357 : struct stat st;
1731 357 : unsigned bbpversion = 0;
1732 357 : int i;
1733 357 : int lineno = 0;
1734 : #ifdef GDKLIBRARY_HASHASH
1735 357 : bat *hashbats = NULL;
1736 357 : bat nhashbats = 0;
1737 357 : gdk_return res = GDK_SUCCEED;
1738 : #endif
1739 357 : ATOMIC_BASE_TYPE dbg = ATOMIC_GET(&GDKdebug);
1740 :
1741 357 : ATOMIC_AND(&GDKdebug, ~TAILCHKMASK);
1742 :
1743 : /* the maximum number of BATs allowed in the system and the
1744 : * size of the "physical" array are linked in a complicated
1745 : * manner. The expression below shows the relationship */
1746 357 : static_assert((uint64_t) N_BBPINIT * BBPINIT < (UINT64_C(1) << (3 * ((sizeof(BBP[0][0].physical) + 2) * 2 / 5))), "\"physical\" array in BBPrec is too small");
1747 : /* similarly, the maximum number of BATs allowed also has a
1748 : * (somewhat simpler) relation with the size of the "bak"
1749 : * array */
1750 357 : static_assert((uint64_t) N_BBPINIT * BBPINIT < (UINT64_C(1) << (3 * (sizeof(BBP[0][0].bak) - 5))), "\"bak\" array in BBPrec is too small");
1751 :
1752 357 : if (!GDKinmemory(0)) {
1753 356 : char bbpdirstr[MAXPATH], backupbbpdirstr[MAXPATH];
1754 :
1755 356 : BBPtmlock();
1756 :
1757 356 : if (GDKfilepath(bbpdirstr, sizeof(bbpdirstr), 0, BATDIR, "BBP", "dir") != GDK_SUCCEED) {
1758 0 : TRC_CRITICAL(GDK, "GDKmalloc failed\n");
1759 0 : BBPtmunlock();
1760 0 : ATOMIC_SET(&GDKdebug, dbg);
1761 0 : return GDK_FAIL;
1762 : }
1763 :
1764 356 : if (GDKfilepath(backupbbpdirstr, sizeof(backupbbpdirstr), 0, BAKDIR, "BBP", "dir") != GDK_SUCCEED) {
1765 0 : TRC_CRITICAL(GDK, "GDKmalloc failed\n");
1766 0 : BBPtmunlock();
1767 0 : ATOMIC_SET(&GDKdebug, dbg);
1768 0 : return GDK_FAIL;
1769 : }
1770 :
1771 356 : if (GDKremovedir(0, TEMPDIR) != GDK_SUCCEED) {
1772 0 : TRC_CRITICAL(GDK, "cannot remove directory %s\n", TEMPDIR);
1773 0 : BBPtmunlock();
1774 0 : ATOMIC_SET(&GDKdebug, dbg);
1775 0 : return GDK_FAIL;
1776 : }
1777 :
1778 356 : if (GDKremovedir(0, DELDIR) != GDK_SUCCEED) {
1779 0 : TRC_CRITICAL(GDK, "cannot remove directory %s\n", DELDIR);
1780 0 : BBPtmunlock();
1781 0 : ATOMIC_SET(&GDKdebug, dbg);
1782 0 : return GDK_FAIL;
1783 : }
1784 :
1785 : /* first move everything from SUBDIR to BAKDIR (its parent) */
1786 356 : if (BBPrecover_subdir() != GDK_SUCCEED) {
1787 0 : TRC_CRITICAL(GDK, "cannot properly recover_subdir process %s.", SUBDIR);
1788 0 : BBPtmunlock();
1789 0 : ATOMIC_SET(&GDKdebug, dbg);
1790 0 : return GDK_FAIL;
1791 : }
1792 :
1793 : /* try to obtain a BBP.dir from bakdir */
1794 356 : if (MT_stat(backupbbpdirstr, &st) == 0) {
1795 : /* backup exists; *must* use it */
1796 127 : if (recover_dir(0, MT_stat(bbpdirstr, &st) == 0) != GDK_SUCCEED) {
1797 0 : BBPtmunlock();
1798 0 : goto bailout;
1799 : }
1800 127 : if ((fp = GDKfilelocate(0, "BBP", "r", "dir")) == NULL) {
1801 0 : TRC_CRITICAL(GDK, "cannot open recovered BBP.dir.");
1802 0 : BBPtmunlock();
1803 0 : ATOMIC_SET(&GDKdebug, dbg);
1804 0 : return GDK_FAIL;
1805 : }
1806 229 : } else if ((fp = GDKfilelocate(0, "BBP", "r", "dir")) == NULL) {
1807 : /* there was no BBP.dir either. Panic! try to use a
1808 : * BBP.bak */
1809 229 : if (MT_stat(backupbbpdirstr, &st) < 0) {
1810 : /* no BBP.bak (nor BBP.dir or BACKUP/BBP.dir):
1811 : * create a new one */
1812 229 : TRC_DEBUG(IO, "initializing BBP.\n");
1813 229 : if (BBPdir_init() != GDK_SUCCEED) {
1814 0 : BBPtmunlock();
1815 0 : goto bailout;
1816 : }
1817 0 : } else if (GDKmove(0, BATDIR, "BBP", "bak", BATDIR, "BBP", "dir", true) == GDK_SUCCEED)
1818 0 : TRC_DEBUG(IO, "reverting to dir saved in BBP.bak.\n");
1819 :
1820 229 : if ((fp = GDKfilelocate(0, "BBP", "r", "dir")) == NULL) {
1821 0 : GDKsyserror("cannot open BBP.dir");
1822 0 : BBPtmunlock();
1823 0 : goto bailout;
1824 : }
1825 : }
1826 : assert(fp != NULL);
1827 356 : BBPtmunlock();
1828 : }
1829 :
1830 : /* scan the BBP.dir to obtain current size */
1831 357 : BBPlimit = BBPINIT;
1832 357 : memset(BBP0, 0, sizeof(BBP0));
1833 357 : memset(BBP, 0, sizeof(BBP));
1834 357 : BBP[0] = BBP0;
1835 :
1836 357 : bat bbpsize;
1837 357 : bbpsize = 1;
1838 357 : if (GDKinmemory(0)) {
1839 : bbpversion = GDKLIBRARY;
1840 : } else {
1841 356 : lng logno;
1842 356 : bbpversion = BBPheader(fp, &lineno, &bbpsize, &logno, allow_hge_upgrade);
1843 356 : if (bbpversion == 0) {
1844 0 : ATOMIC_SET(&GDKdebug, dbg);
1845 0 : return GDK_FAIL;
1846 : }
1847 356 : ATOMIC_SET(&BBPlogno, logno);
1848 : }
1849 :
1850 : /* allocate BBP records */
1851 357 : if (BBPextend(bbpsize) != GDK_SUCCEED) {
1852 0 : ATOMIC_SET(&GDKdebug, dbg);
1853 0 : return GDK_FAIL;
1854 : }
1855 357 : ATOMIC_SET(&BBPsize, bbpsize);
1856 :
1857 357 : if (!GDKinmemory(0)) {
1858 356 : if (BBPreadEntries(fp, bbpversion, lineno
1859 : #ifdef GDKLIBRARY_HASHASH
1860 : , &hashbats, &nhashbats
1861 : #endif
1862 : ) != GDK_SUCCEED) {
1863 0 : ATOMIC_SET(&GDKdebug, dbg);
1864 0 : return GDK_FAIL;
1865 : }
1866 356 : fclose(fp);
1867 : }
1868 :
1869 : /* remove trailing free bats from potential free list (they will
1870 : * get added when needed) */
1871 27718 : for (bat i = (bat) ATOMIC_GET(&BBPsize) - 1; i > 0; i--) {
1872 27488 : if (BBP_desc(i)->batCacheid != 0)
1873 : break;
1874 27361 : bbpsize--;
1875 : }
1876 357 : ATOMIC_SET(&BBPsize, bbpsize);
1877 :
1878 : /* add free bats to free list in such a way that low numbered
1879 : * ones are at the head of the list */
1880 81700 : for (bat i = (bat) ATOMIC_GET(&BBPsize) - 1; i > 0; i--) {
1881 81343 : if (BBP_desc(i)->batCacheid == 0) {
1882 47445 : BBP_next(i) = BBP_free;
1883 47445 : BBP_free = i;
1884 47445 : BBP_nfree++;
1885 : }
1886 : }
1887 :
1888 : /* will call BBPrecover if needed */
1889 357 : if (!GDKinmemory(0)) {
1890 356 : BBPtmlock();
1891 356 : gdk_return rc = BBPprepare(false);
1892 356 : BBPtmunlock();
1893 356 : if (rc != GDK_SUCCEED) {
1894 : #ifdef GDKLIBRARY_HASHASH
1895 0 : GDKfree(hashbats);
1896 : #endif
1897 0 : TRC_CRITICAL(GDK, "cannot properly prepare process %s.", BAKDIR);
1898 0 : ATOMIC_SET(&GDKdebug, dbg);
1899 0 : return rc;
1900 : }
1901 : }
1902 :
1903 357 : if (BBPcheckbats(bbpversion) != GDK_SUCCEED) {
1904 : #ifdef GDKLIBRARY_HASHASH
1905 0 : GDKfree(hashbats);
1906 : #endif
1907 0 : ATOMIC_SET(&GDKdebug, dbg);
1908 0 : return GDK_FAIL;
1909 : }
1910 :
1911 : #ifdef GDKLIBRARY_HASHASH
1912 357 : if (nhashbats > 0)
1913 0 : res = fixhashash(hashbats, nhashbats);
1914 357 : GDKfree(hashbats);
1915 357 : if (res != GDK_SUCCEED)
1916 : return res;
1917 : #endif
1918 :
1919 : #ifdef GDKLIBRARY_JSON
1920 357 : if (bbpversion <= GDKLIBRARY_JSON && !GDKinmemory(0)) {
1921 0 : char jsonupgradestr[MAXPATH];
1922 :
1923 0 : if (GDKfilepath(jsonupgradestr, sizeof(jsonupgradestr), 0, BATDIR, "jsonupgradeneeded", NULL) != GDK_SUCCEED) {
1924 0 : TRC_CRITICAL(GDK, "GDKfilepath failed\n");
1925 0 : ATOMIC_SET(&GDKdebug, dbg);
1926 0 : return GDK_FAIL;
1927 : }
1928 :
1929 : /* create signal file that we need to upgrade stored
1930 : * json strings. This will be performed by an upgrade
1931 : * function in the GDK that will be called at the end of
1932 : * the json module initialization with a callback that
1933 : * actually knows how to perform the upgrade. */
1934 0 : int fd = MT_open(jsonupgradestr, O_WRONLY | O_CREAT);
1935 0 : if (fd < 0) {
1936 0 : TRC_CRITICAL(GDK, "cannot create signal file jsonupgradeneeded");
1937 0 : ATOMIC_SET(&GDKdebug, dbg);
1938 0 : return GDK_FAIL;
1939 : }
1940 :
1941 0 : close(fd);
1942 : }
1943 : #endif
1944 :
1945 357 : if (bbpversion < GDKLIBRARY && TMcommit() != GDK_SUCCEED) {
1946 0 : TRC_CRITICAL(GDK, "TMcommit failed\n");
1947 0 : ATOMIC_SET(&GDKdebug, dbg);
1948 0 : return GDK_FAIL;
1949 : }
1950 :
1951 357 : ATOMIC_SET(&GDKdebug, dbg);
1952 :
1953 : /* cleanup any leftovers (must be done after BBPrecover) */
1954 1414 : for (i = 0; i < MAXFARMS && BBPfarms[i].dirname != NULL; i++) {
1955 : int j;
1956 1439 : for (j = 0; j < i; j++) {
1957 : /* don't clean a directory twice */
1958 892 : if (BBPfarms[j].dirname &&
1959 892 : strcmp(BBPfarms[i].dirname,
1960 : BBPfarms[j].dirname) == 0)
1961 : break;
1962 : }
1963 1057 : if (j == i) {
1964 547 : char d[MAXPATH];
1965 :
1966 547 : if (GDKfilepath(d, sizeof(d), i, NULL, BATDIR, NULL) != GDK_SUCCEED) {
1967 0 : return GDK_FAIL;
1968 : }
1969 547 : BBPdiskscan(d, strlen(d) - strlen(BATDIR));
1970 : }
1971 : }
1972 :
1973 357 : if (!GDKinmemory(0) && !no_manager && MT_create_thread(&manager, BBPmanager, NULL, MT_THR_DETACHED, "BBPmanager") < 0) {
1974 0 : TRC_CRITICAL(GDK, "Could not start BBPmanager thread.");
1975 0 : return GDK_FAIL;
1976 : }
1977 : return GDK_SUCCEED;
1978 :
1979 0 : bailout:
1980 : /* now it is time for real panic */
1981 0 : TRC_CRITICAL(GDK, "could not write %s%cBBP.dir.", BATDIR, DIR_SEP);
1982 0 : return GDK_FAIL;
1983 : }
1984 :
1985 : /*
1986 : * During the exit phase all non-persistent BATs are removed. Upon
1987 : * exit the status of the BBP tables is saved on disk. This function
1988 : * is called once and during the shutdown of the server. Since
1989 : * shutdown may be issued from any thread (dangerous) it may lead to
1990 : * interference in a parallel session.
1991 : */
1992 :
1993 : static int backup_files = 0, backup_dir = 0, backup_subdir = 0;
1994 :
1995 : void
1996 355 : BBPexit(void)
1997 : {
1998 355 : bat i;
1999 355 : bool skipped;
2000 :
2001 : //BBPlock(); /* stop all threads ever touching more descriptors */
2002 :
2003 : /* free all memory (just for leak-checking in Purify) */
2004 355 : do {
2005 355 : skipped = false;
2006 482475 : for (i = 0; i < (bat) ATOMIC_GET(&BBPsize); i++) {
2007 482120 : if (BBPvalid(i)) {
2008 344541 : BAT *b = BBP_desc(i);
2009 :
2010 344541 : if (b->batCacheid != 0) {
2011 344541 : if (BATshared(b)) {
2012 0 : skipped = true;
2013 0 : continue;
2014 : }
2015 344541 : MT_lock_set(&b->theaplock);
2016 344541 : bat tp = VIEWtparent(b);
2017 0 : if (tp != 0) {
2018 0 : --BBP_lrefs(tp);
2019 0 : HEAPdecref(b->theap, false);
2020 0 : b->theap = NULL;
2021 : }
2022 344541 : tp = VIEWvtparent(b);
2023 0 : if (tp != 0) {
2024 0 : --BBP_lrefs(tp);
2025 0 : HEAPdecref(b->tvheap, false);
2026 0 : b->tvheap = NULL;
2027 : }
2028 344541 : if (b->oldtail) {
2029 6 : Heap *h = b->oldtail;
2030 6 : b->oldtail = NULL;
2031 6 : ATOMIC_AND(&h->refs, ~DELAYEDREMOVE);
2032 6 : HEAPdecref(h, false);
2033 : }
2034 344541 : PROPdestroy_nolock(b);
2035 344541 : MT_lock_unset(&b->theaplock);
2036 344541 : BATfree(b);
2037 : }
2038 344541 : BBP_pid(i) = 0;
2039 344541 : BBPuncacheit(i, true);
2040 344541 : if (BBP_logical(i) != BBP_bak(i))
2041 11576 : GDKfree(BBP_logical(i));
2042 344541 : BBP_logical(i) = NULL;
2043 : }
2044 : }
2045 355 : } while (skipped);
2046 : /* these need to be NULL, otherwise no new ones get created */
2047 355 : memset(BBP_hash, 0, sizeof(BBP_hash));
2048 355 : backup_files = 0;
2049 355 : backup_dir = 0;
2050 355 : backup_subdir = 0;
2051 355 : }
2052 :
2053 : /*
2054 : * The routine BBPdir creates the BAT pool dictionary file. It
2055 : * includes some information about the current state of affair in the
2056 : * pool. The location in the buffer pool is saved for later use as
2057 : * well. This is merely done for ease of debugging and of no
2058 : * importance to front-ends. The tail of non-used entries is
2059 : * reclaimed as well.
2060 : */
2061 : static inline int
2062 1888915 : heap_entry(FILE *fp, BATiter *bi, BUN size)
2063 : {
2064 1888915 : size_t free = bi->hfree;
2065 1888915 : if (size < BUN_NONE) {
2066 1888915 : if ((bi->type >= 0 && ATOMstorage(bi->type) == TYPE_msk))
2067 296684 : free = ((size + 31) / 32) * 4;
2068 1592231 : else if (bi->width > 0)
2069 1592231 : free = size << bi->shift;
2070 : else
2071 : free = 0;
2072 : }
2073 :
2074 5988324 : return fprintf(fp, " %s %d %d %d " BUNFMT " " BUNFMT " " BUNFMT " "
2075 : BUNFMT " " OIDFMT " %zu %" PRIu64" %" PRIu64,
2076 1888915 : bi->type >= 0 ? BATatoms[bi->type].name : ATOMunknown_name(bi->type),
2077 1888915 : bi->width,
2078 1888915 : bi->type == TYPE_void || bi->vh != NULL,
2079 1888915 : (unsigned short) bi->sorted |
2080 1888915 : ((unsigned short) bi->revsorted << 7) |
2081 3777830 : ((unsigned short) bi->key << 8) |
2082 1888915 : ((unsigned short) BATtdensebi(bi) << 9) |
2083 1888915 : ((unsigned short) bi->nonil << 10) |
2084 1888915 : ((unsigned short) bi->nil << 11) |
2085 1888915 : ((unsigned short) bi->ascii << 12),
2086 1164829 : bi->nokey[0] >= size || bi->nokey[1] >= size ? 0 : bi->nokey[0],
2087 1888915 : bi->nokey[0] >= size || bi->nokey[1] >= size ? 0 : bi->nokey[1],
2088 1888915 : bi->nosorted >= size ? 0 : bi->nosorted,
2089 1888915 : bi->norevsorted >= size ? 0 : bi->norevsorted,
2090 : bi->tseq,
2091 : free,
2092 1888915 : bi->minpos < size ? (uint64_t) bi->minpos : (uint64_t) oid_nil,
2093 1888915 : bi->maxpos < size ? (uint64_t) bi->maxpos : (uint64_t) oid_nil);
2094 : }
2095 :
2096 : static inline int
2097 1888915 : vheap_entry(FILE *fp, BATiter *bi, BUN size)
2098 : {
2099 1888915 : (void) size;
2100 1888915 : if (bi->vh == NULL)
2101 : return 0;
2102 428399 : return fprintf(fp, " %zu", size == 0 ? 0 : bi->vhfree);
2103 : }
2104 :
2105 : static gdk_return
2106 1888915 : new_bbpentry(FILE *fp, bat i, BUN size, BATiter *bi)
2107 : {
2108 : #ifndef NDEBUG
2109 1888915 : assert(i > 0);
2110 1888915 : assert(i < (bat) ATOMIC_GET(&BBPsize));
2111 1888915 : assert(bi->b);
2112 1888915 : assert(bi->b->batCacheid == i);
2113 1888915 : assert(bi->b->batRole == PERSISTENT);
2114 1888915 : assert(0 <= bi->h->farmid && bi->h->farmid < MAXFARMS);
2115 1888915 : assert(BBPfarms[bi->h->farmid].roles & (1U << PERSISTENT));
2116 1888915 : if (bi->vh) {
2117 428399 : assert(0 <= bi->vh->farmid && bi->vh->farmid < MAXFARMS);
2118 428399 : assert(BBPfarms[bi->vh->farmid].roles & (1U << PERSISTENT));
2119 : }
2120 1888915 : assert(size <= bi->count || size == BUN_NONE);
2121 1888915 : assert(BBP_options(i) == NULL || strpbrk(BBP_options(i), "\r\n") == NULL);
2122 : #endif
2123 :
2124 1888915 : if (BBP_options(i) != NULL && strpbrk(BBP_options(i), "\r\n") != NULL) {
2125 0 : GDKerror("options for bat %d contains a newline\n", i);
2126 0 : return GDK_FAIL;
2127 : }
2128 1888915 : if (size > bi->count)
2129 : size = bi->count;
2130 1888915 : if (fprintf(fp, "%d %s %d " BUNFMT " " OIDFMT,
2131 : /* BAT info */
2132 : (int) i,
2133 : BBP_logical(i),
2134 1888915 : (unsigned) bi->restricted << 1,
2135 : size,
2136 1888915 : bi->b->hseqbase) < 0 ||
2137 3777830 : heap_entry(fp, bi, size) < 0 ||
2138 1888915 : vheap_entry(fp, bi, size) < 0 ||
2139 3777830 : (BBP_options(i) && fprintf(fp, " %s", BBP_options(i)) < 0) ||
2140 1888915 : fprintf(fp, "\n") < 0) {
2141 0 : GDKsyserror("new_bbpentry: Writing BBP.dir entry failed\n");
2142 0 : return GDK_FAIL;
2143 : }
2144 :
2145 : return GDK_SUCCEED;
2146 : }
2147 :
2148 : static gdk_return
2149 13559 : BBPdir_header(FILE *f, int n, lng logno)
2150 : {
2151 13559 : if (fprintf(f, "BBP.dir, GDKversion %u\n%d %d %d\nBBPsize=%d\nBBPinfo=" LLFMT "\n",
2152 : GDKLIBRARY, SIZEOF_SIZE_T, SIZEOF_OID,
2153 : #ifdef HAVE_HGE
2154 : SIZEOF_HGE
2155 : #else
2156 : SIZEOF_LNG
2157 : #endif
2158 13559 : , n, logno) < 0 ||
2159 13559 : ferror(f)) {
2160 0 : GDKsyserror("Writing BBP.dir header failed\n");
2161 0 : return GDK_FAIL;
2162 : }
2163 : return GDK_SUCCEED;
2164 : }
2165 :
2166 : static gdk_return
2167 13559 : BBPdir_first(bool subcommit, lng logno, FILE **obbpfp, FILE **nbbpfp)
2168 : {
2169 13559 : FILE *obbpf = NULL, *nbbpf = NULL;
2170 13559 : int n = 0;
2171 13559 : lng ologno;
2172 :
2173 13559 : if (obbpfp)
2174 13330 : *obbpfp = NULL;
2175 13559 : *nbbpfp = NULL;
2176 :
2177 13559 : if ((nbbpf = GDKfilelocate(0, "BBP", "w", "dir")) == NULL) {
2178 : return GDK_FAIL;
2179 : }
2180 :
2181 13559 : if (subcommit) {
2182 13322 : char buf[512];
2183 :
2184 13322 : assert(obbpfp != NULL);
2185 : /* we need to copy the backup BBP.dir to the new, but
2186 : * replacing the entries for the subcommitted bats */
2187 13322 : if ((obbpf = GDKfileopen(0, SUBDIR, "BBP", "dir", "r")) == NULL &&
2188 0 : (obbpf = GDKfileopen(0, BAKDIR, "BBP", "dir", "r")) == NULL) {
2189 0 : GDKsyserror("subcommit attempted without backup BBP.dir");
2190 0 : goto bailout;
2191 : }
2192 : /* read first three lines */
2193 26644 : if (fgets(buf, sizeof(buf), obbpf) == NULL || /* BBP.dir, GDKversion %d */
2194 26644 : fgets(buf, sizeof(buf), obbpf) == NULL || /* SIZEOF_SIZE_T SIZEOF_OID SIZEOF_MAX_INT */
2195 13322 : fgets(buf, sizeof(buf), obbpf) == NULL) { /* BBPsize=%d */
2196 0 : GDKerror("subcommit attempted with invalid backup BBP.dir.");
2197 0 : goto bailout;
2198 : }
2199 : /* third line contains BBPsize */
2200 13322 : if (sscanf(buf, "BBPsize=%d", &n) != 1) {
2201 0 : GDKerror("cannot read BBPsize in backup BBP.dir.");
2202 0 : goto bailout;
2203 : }
2204 : /* fourth line contains BBPinfo */
2205 13322 : if (fgets(buf, sizeof(buf), obbpf) == NULL ||
2206 13322 : sscanf(buf, "BBPinfo=" LLSCN, &ologno) != 1) {
2207 0 : GDKerror("cannot read BBPinfo in backup BBP.dir.");
2208 0 : goto bailout;
2209 : }
2210 : }
2211 :
2212 13559 : if (n < (bat) ATOMIC_GET(&BBPsize))
2213 2671 : n = (bat) ATOMIC_GET(&BBPsize);
2214 :
2215 13559 : TRC_DEBUG(IO, "writing BBP.dir (%d bats).\n", n);
2216 :
2217 13559 : if (BBPdir_header(nbbpf, n, logno) != GDK_SUCCEED) {
2218 0 : goto bailout;
2219 : }
2220 :
2221 13559 : if (obbpfp)
2222 13330 : *obbpfp = obbpf;
2223 13559 : *nbbpfp = nbbpf;
2224 :
2225 13559 : return GDK_SUCCEED;
2226 :
2227 0 : bailout:
2228 0 : if (obbpf != NULL)
2229 0 : fclose(obbpf);
2230 0 : if (nbbpf != NULL)
2231 0 : fclose(nbbpf);
2232 0 : return GDK_FAIL;
2233 : }
2234 :
2235 : static bat
2236 2084231 : BBPdir_step(bat bid, BUN size, int n, char *buf, size_t bufsize,
2237 : FILE **obbpfp, FILE *nbbpf, BATiter *bi, int *nbatp)
2238 : {
2239 2084231 : if (n < -1) /* safety catch */
2240 : return n;
2241 : int nbat = 0;
2242 5516725 : while (n >= 0 && n < bid) {
2243 3432494 : if (n > 0) {
2244 1603952 : if (fputs(buf, nbbpf) == EOF) {
2245 0 : GDKerror("Writing BBP.dir file failed.\n");
2246 0 : goto bailout;
2247 : }
2248 1603952 : nbat++;
2249 : }
2250 3432494 : if (fgets(buf, (int) bufsize, *obbpfp) == NULL) {
2251 3343 : if (ferror(*obbpfp)) {
2252 0 : GDKerror("error reading backup BBP.dir.");
2253 0 : goto bailout;
2254 : }
2255 3343 : n = -1;
2256 3343 : if (fclose(*obbpfp) == EOF) {
2257 0 : GDKsyserror("Closing backup BBP.dir file failed\n");
2258 0 : GDKclrerr(); /* ignore error */
2259 : }
2260 3343 : *obbpfp = NULL;
2261 : } else {
2262 3429151 : if (sscanf(buf, "%d", &n) != 1 || n <= 0 || n >= N_BBPINIT * BBPINIT) {
2263 0 : GDKerror("subcommit attempted with invalid backup BBP.dir.");
2264 0 : goto bailout;
2265 : }
2266 : }
2267 : }
2268 2084231 : if (bi) {
2269 1888915 : assert(BBP_status(bid) & BBPPERSISTENT);
2270 1888915 : if (new_bbpentry(nbbpf, bid, size, bi) != GDK_SUCCEED)
2271 0 : goto bailout;
2272 1888915 : nbat++;
2273 : }
2274 2084231 : *nbatp += nbat;
2275 2084231 : return n == -1 ? -1 : n == bid ? 0 : n;
2276 :
2277 0 : bailout:
2278 0 : if (*obbpfp)
2279 0 : fclose(*obbpfp);
2280 0 : fclose(nbbpf);
2281 0 : return -2;
2282 : }
2283 :
2284 : static gdk_return
2285 13559 : BBPdir_last(int n, char *buf, size_t bufsize, FILE *obbpf, FILE *nbbpf)
2286 : {
2287 13559 : if (n > 0 && fputs(buf, nbbpf) == EOF) {
2288 0 : GDKerror("Writing BBP.dir file failed.\n");
2289 0 : goto bailout;
2290 : }
2291 336292 : while (obbpf) {
2292 332712 : if (fgets(buf, (int) bufsize, obbpf) == NULL) {
2293 9979 : if (ferror(obbpf)) {
2294 0 : GDKerror("error reading backup BBP.dir.");
2295 0 : goto bailout;
2296 : }
2297 9979 : if (fclose(obbpf) == EOF) {
2298 0 : GDKsyserror("Closing backup BBP.dir file failed\n");
2299 0 : GDKclrerr(); /* ignore error */
2300 : }
2301 : obbpf = NULL;
2302 : } else {
2303 322733 : if (fputs(buf, nbbpf) == EOF) {
2304 0 : GDKerror("Writing BBP.dir file failed.\n");
2305 0 : goto bailout;
2306 : }
2307 : }
2308 : }
2309 13559 : if (fflush(nbbpf) == EOF ||
2310 13559 : (!(ATOMIC_GET(&GDKdebug) & NOSYNCMASK)
2311 : #if defined(NATIVE_WIN32)
2312 : && _commit(_fileno(nbbpf)) < 0
2313 : #elif defined(HAVE_FDATASYNC)
2314 5 : && fdatasync(fileno(nbbpf)) < 0
2315 : #elif defined(HAVE_FSYNC)
2316 : && fsync(fileno(nbbpf)) < 0
2317 : #endif
2318 : )) {
2319 0 : GDKsyserror("Syncing BBP.dir file failed\n");
2320 0 : goto bailout;
2321 : }
2322 13559 : if (fclose(nbbpf) == EOF) {
2323 0 : GDKsyserror("Closing BBP.dir file failed\n");
2324 0 : nbbpf = NULL; /* can't close again */
2325 0 : goto bailout;
2326 : }
2327 :
2328 13559 : TRC_DEBUG(IO, "end\n");
2329 :
2330 : return GDK_SUCCEED;
2331 :
2332 0 : bailout:
2333 0 : if (obbpf != NULL)
2334 0 : fclose(obbpf);
2335 0 : if (nbbpf != NULL)
2336 0 : fclose(nbbpf);
2337 : return GDK_FAIL;
2338 : }
2339 :
2340 : gdk_return
2341 229 : BBPdir_init(void)
2342 : {
2343 229 : FILE *fp;
2344 229 : gdk_return rc;
2345 :
2346 229 : rc = BBPdir_first(false, 0, NULL, &fp);
2347 229 : if (rc == GDK_SUCCEED)
2348 229 : rc = BBPdir_last(-1, NULL, 0, NULL, fp);
2349 229 : return rc;
2350 : }
2351 :
2352 : /* function used for debugging */
2353 : void
2354 0 : BBPdump(void)
2355 : {
2356 0 : size_t mem = 0, vm = 0;
2357 0 : int n = 0;
2358 :
2359 0 : for (bat i = 0; i < (bat) ATOMIC_GET(&BBPsize); i++) {
2360 0 : if (BBP_refs(i) == 0 && BBP_lrefs(i) == 0)
2361 0 : continue;
2362 0 : BAT *b = BBP_desc(i);
2363 0 : unsigned status = BBP_status(i);
2364 0 : printf("# %d: " ALGOOPTBATFMT " refs=%d lrefs=%d status=%u%s",
2365 : i,
2366 0 : ALGOOPTBATPAR(b),
2367 : BBP_refs(i),
2368 0 : BBP_lrefs(i),
2369 : status,
2370 0 : status & BBPLOADED ? "" : " not cached");
2371 0 : if (b->batCacheid == 0) {
2372 0 : printf(", no descriptor\n");
2373 0 : continue;
2374 : }
2375 0 : if (b->theap) {
2376 0 : if (b->theap->parentid != b->batCacheid) {
2377 0 : printf(" Theap -> %d", b->theap->parentid);
2378 : } else {
2379 0 : printf(" Theap=[%zu,%zu,f=%d]%s%s",
2380 : b->theap->free,
2381 : b->theap->size,
2382 0 : b->theap->farmid,
2383 0 : b->theap->base == NULL ? "X" : b->theap->storage == STORE_MMAP ? "M" : "",
2384 0 : status & BBPSWAPPED ? "(Swapped)" : b->theap->dirty ? "(Dirty)" : "");
2385 0 : mem += HEAPmemsize(b->theap);
2386 0 : vm += HEAPvmsize(b->theap);
2387 0 : n++;
2388 : }
2389 : }
2390 0 : if (b->tvheap) {
2391 0 : if (b->tvheap->parentid != b->batCacheid) {
2392 0 : printf(" Tvheap -> %d",
2393 : b->tvheap->parentid);
2394 : } else {
2395 0 : printf(" Tvheap=[%zu,%zu,f=%d]%s%s",
2396 : b->tvheap->free,
2397 : b->tvheap->size,
2398 0 : b->tvheap->farmid,
2399 0 : b->tvheap->base == NULL ? "X" : b->tvheap->storage == STORE_MMAP ? "M" : "",
2400 0 : b->tvheap->dirty ? "(Dirty)" : "");
2401 0 : mem += HEAPmemsize(b->tvheap);
2402 0 : vm += HEAPvmsize(b->tvheap);
2403 : }
2404 : }
2405 0 : if (MT_rwlock_rdtry(&b->thashlock)) {
2406 0 : if (b->thash && b->thash != (Hash *) 1) {
2407 0 : size_t m = HEAPmemsize(&b->thash->heaplink) + HEAPmemsize(&b->thash->heapbckt);
2408 0 : size_t v = HEAPvmsize(&b->thash->heaplink) + HEAPvmsize(&b->thash->heapbckt);
2409 0 : printf(" Thash=[%zu,%zu,f=%d/%d]", m, v,
2410 0 : b->thash->heaplink.farmid,
2411 0 : b->thash->heapbckt.farmid);
2412 0 : mem += m;
2413 0 : vm += v;
2414 : }
2415 0 : MT_rwlock_rdunlock(&b->thashlock);
2416 : }
2417 0 : printf(" role: %s\n",
2418 0 : b->batRole == PERSISTENT ? "persistent" : "transient");
2419 : }
2420 0 : printf("# %d bats: mem=%zu, vm=%zu\n", n, mem, vm);
2421 0 : fflush(stdout);
2422 0 : }
2423 :
2424 : /*
2425 : * @+ BBP Readonly Interface
2426 : *
2427 : * These interface functions do not change the BBP tables. If they
2428 : * only access one specific BAT, the caller must have ensured that no
2429 : * other thread is modifying that BAT, therefore such functions do not
2430 : * need locking.
2431 : *
2432 : * BBP index lookup by BAT name:
2433 : */
2434 : static inline bat
2435 44575 : BBP_find(const char *nme, bool lock)
2436 : {
2437 44575 : bat i = BBPnamecheck(nme);
2438 :
2439 15285 : if (i != 0) {
2440 : /* for tmp_X BATs, we already know X */
2441 15285 : const char *s;
2442 :
2443 15285 : if (i >= (bat) ATOMIC_GET(&BBPsize) || (s = BBP_logical(i)) == NULL || strcmp(s, nme)) {
2444 15285 : i = 0;
2445 : }
2446 29290 : } else if (*nme != '.') {
2447 : /* must lock since hash-lookup traverses other BATs */
2448 29290 : if (lock)
2449 1692 : MT_lock_set(&BBPnameLock);
2450 29318 : for (i = BBP_hash[strHash(nme) & BBP_mask]; i; i = BBP_next(i)) {
2451 921 : if (strcmp(BBP_logical(i), nme) == 0)
2452 : break;
2453 : }
2454 29290 : if (lock)
2455 1692 : MT_lock_unset(&BBPnameLock);
2456 : }
2457 44575 : return i;
2458 : }
2459 :
2460 : bat
2461 1692 : BBPindex(const char *nme)
2462 : {
2463 1692 : return BBP_find(nme, true);
2464 : }
2465 :
2466 : /*
2467 : * @+ BBP Update Interface
2468 : * Operations to insert, delete, clear, and modify BBP entries.
2469 : * Our policy for the BBP is to provide unlocked BBP access for
2470 : * speed, but still write operations have to be locked.
2471 : * #ifdef DEBUG_THREADLOCAL_BATS
2472 : * Create the shadow version (reversed) of a bat.
2473 : *
2474 : * An existing BAT is inserted into the BBP
2475 : */
2476 :
2477 : /* The free list is empty. We create a new entry by either just
2478 : * increasing BBPsize (up to BBPlimit) or extending the BBP (which
2479 : * increases BBPlimit).
2480 : *
2481 : * Note that this is the only place in normal, multi-threaded operation
2482 : * where BBPsize is assigned a value (never decreasing) and that the
2483 : * assignment happens after any necessary memory was allocated and
2484 : * initialized. */
2485 : static gdk_return
2486 40087 : maybeextend(void)
2487 : {
2488 40087 : bat size = (bat) ATOMIC_GET(&BBPsize);
2489 40087 : if (size + BBP_FREE_LOWATER > BBPlimit &&
2490 0 : BBPextend(size + BBP_FREE_LOWATER) != GDK_SUCCEED) {
2491 : /* nothing available */
2492 : return GDK_FAIL;
2493 : }
2494 40087 : ATOMIC_SET(&BBPsize, size + BBP_FREE_LOWATER);
2495 40087 : assert(BBP_free == 0);
2496 40087 : BBP_free = size;
2497 400870 : for (int i = 1; i < BBP_FREE_LOWATER; i++) {
2498 360783 : bat sz = size;
2499 360783 : BBP_next(sz) = ++size;
2500 : }
2501 40087 : BBP_next(size) = 0;
2502 40087 : BBP_nfree += BBP_FREE_LOWATER;
2503 40087 : return GDK_SUCCEED;
2504 : }
2505 :
2506 : /* return new BAT id (> 0); return 0 on failure */
2507 : bat
2508 20365335 : BBPallocbat(int tt)
2509 : {
2510 20365335 : MT_Id pid = MT_getpid();
2511 20363500 : bool lock = locked_by == 0 || locked_by != pid;
2512 20363500 : bat i;
2513 20363500 : struct freebats *t = MT_thread_getfreebats();
2514 :
2515 20361615 : if (t->freebats == 0) {
2516 : /* critical section: get a new BBP entry */
2517 205091 : assert(t->nfreebats == 0);
2518 205091 : if (lock) {
2519 205091 : MT_lock_set(&GDKcacheLock);
2520 : }
2521 :
2522 : /* get a global bat, perhaps extend */
2523 205103 : if (BBP_free <= 0) {
2524 : /* we need to extend the BBP */
2525 40087 : gdk_return r;
2526 40087 : r = maybeextend();
2527 40087 : if (r != GDK_SUCCEED) {
2528 0 : if (lock) {
2529 0 : MT_lock_unset(&GDKcacheLock);
2530 : }
2531 : /* failed */
2532 0 : return 0;
2533 : }
2534 : }
2535 205103 : t->freebats = i = BBP_free;
2536 205103 : bat l = 0;
2537 2223337 : for (int x = 0; x < BBP_FREE_LOWATER && i; x++) {
2538 2018234 : assert(BBP_next(i) == 0 || BBP_next(i) > i);
2539 2018234 : t->nfreebats++;
2540 2018234 : BBP_nfree--;
2541 2018234 : l = i;
2542 2018234 : i = BBP_next(i);
2543 : }
2544 205103 : BBP_next(l) = 0;
2545 205103 : BBP_free = i;
2546 :
2547 205103 : if (lock) {
2548 205103 : MT_lock_unset(&GDKcacheLock);
2549 : }
2550 : /* rest of the work outside the lock */
2551 : }
2552 20361627 : if (t->nfreebats > 0) {
2553 20361627 : assert(t->freebats > 0);
2554 20361627 : i = t->freebats;
2555 20361627 : t->freebats = BBP_next(i);
2556 20361627 : assert(t->freebats == 0 || t->freebats > i);
2557 20361627 : BBP_next(i) = 0;
2558 20361627 : t->nfreebats--;
2559 : } else {
2560 0 : assert(t->nfreebats == 0);
2561 0 : assert(t->freebats == 0);
2562 : return 0;
2563 : }
2564 :
2565 : /* fill in basic BBP fields for the new bat */
2566 :
2567 20361627 : MT_lock_set(&GDKswapLock(i));
2568 20357158 : BBP_status_set(i, BBPDELETING|BBPHOT);
2569 20357158 : BBP_refs(i) = 1; /* new bats have 1 pin */
2570 20357158 : BBP_lrefs(i) = 0; /* ie. no logical refs */
2571 20357158 : BBP_pid(i) = pid;
2572 20357158 : MT_lock_unset(&GDKswapLock(i));
2573 :
2574 20363056 : if (*BBP_bak(i) == 0) {
2575 434450 : int len;
2576 434450 : len = snprintf(BBP_bak(i), sizeof(BBP_bak(i)), "tmp_%o", (unsigned) i);
2577 434450 : if (len == -1 || (size_t) len >= sizeof(BBP_bak(i))) {
2578 0 : GDKerror("impossible error\n");
2579 0 : return 0;
2580 : }
2581 : }
2582 20363056 : BBP_logical(i) = BBP_bak(i);
2583 :
2584 : /* Keep the physical location around forever */
2585 20363056 : if (!GDKinmemory(0) && *BBP_physical(i) == 0) {
2586 434068 : BBPgetfilename(BBP_physical(i), sizeof(BBP_physical(i)), i);
2587 434119 : TRC_DEBUG(BAT, "%d = new %s(%s)\n", (int) i, BBP_logical(i), ATOMname(tt));
2588 : }
2589 :
2590 : return i;
2591 : }
2592 :
2593 : gdk_return
2594 20388894 : BBPcacheit(BAT *bn, bool lock)
2595 : {
2596 20388894 : bat i = bn->batCacheid;
2597 20388894 : unsigned mode;
2598 :
2599 20388894 : if (lock)
2600 40729536 : lock = locked_by == 0 || locked_by != MT_getpid();
2601 :
2602 20388894 : assert(i > 0);
2603 :
2604 20388894 : if (lock)
2605 20364789 : MT_lock_set(&GDKswapLock(i));
2606 20377099 : mode = (BBP_status(i) | BBPLOADED) & ~(BBPLOADING | BBPDELETING | BBPSWAPPED);
2607 :
2608 : /* cache it! */
2609 20377099 : BBP_status_set(i, mode);
2610 :
2611 20377099 : if (lock)
2612 20359537 : MT_lock_unset(&GDKswapLock(i));
2613 20383562 : return GDK_SUCCEED;
2614 : }
2615 :
2616 : /*
2617 : * BBPuncacheit changes the BBP status to swapped out. Currently only
2618 : * used in BBPfree (bat swapped out) and BBPclear (bat destroyed
2619 : * forever).
2620 : */
2621 :
2622 : static void
2623 20416240 : BBPuncacheit(bat i, bool unloaddesc)
2624 : {
2625 20416240 : if (i < 0)
2626 : i = -i;
2627 20416240 : if (BBPcheck(i)) {
2628 20415285 : BAT *b = BBP_desc(i);
2629 :
2630 20415285 : assert(unloaddesc || BBP_refs(i) == 0);
2631 :
2632 20415285 : if (BBP_status(i) & BBPLOADED) {
2633 20386121 : TRC_DEBUG(BAT, "uncache %d (%s)\n", (int) i, BBP_logical(i));
2634 :
2635 : /* clearing bits can be done without the lock */
2636 20386121 : BBP_status_off(i, BBPLOADED);
2637 : }
2638 20415285 : if (unloaddesc) {
2639 20400875 : BATdestroy(b);
2640 : }
2641 : }
2642 20417283 : }
2643 :
2644 : /*
2645 : * @- BBPclear
2646 : * BBPclear removes a BAT from the BBP directory forever.
2647 : */
2648 : static inline void
2649 73743 : BBPhandover(struct freebats *t, uint32_t n)
2650 : {
2651 73743 : bat *p, bid;
2652 : /* take one bat from our private free list and hand it over to
2653 : * the global free list */
2654 73743 : if (n >= t->nfreebats) {
2655 45153 : bid = t->freebats;
2656 45153 : t->freebats = 0;
2657 45153 : BBP_nfree += t->nfreebats;
2658 45153 : t->nfreebats = 0;
2659 : } else {
2660 28590 : p = &t->freebats;
2661 314490 : for (uint32_t i = n; i < t->nfreebats; i++)
2662 285900 : p = &BBP_next(*p);
2663 28590 : bid = *p;
2664 28590 : *p = 0;
2665 28590 : BBP_nfree += n;
2666 28590 : t->nfreebats -= n;
2667 : }
2668 : p = &BBP_free;
2669 1776195 : while (bid != 0) {
2670 10836491 : while (*p && *p < bid)
2671 9134039 : p = &BBP_next(*p);
2672 1702452 : bat i = BBP_next(bid);
2673 1702452 : BBP_next(bid) = *p;
2674 1702452 : *p = bid;
2675 1702452 : bid = i;
2676 : }
2677 73743 : }
2678 :
2679 : #ifndef NDEBUG
2680 : extern void printlist(bat bid) __attribute__((__cold__));
2681 : /* print a bat free list, pass start of free list as argument
2682 : * to be used from the debugger */
2683 : void
2684 0 : printlist(bat bid)
2685 : {
2686 0 : int n = 0;
2687 0 : while (bid) {
2688 0 : printf("%d ", bid);
2689 0 : bid = BBP_next(bid);
2690 0 : n++;
2691 : }
2692 0 : printf("(%d)\n", n);
2693 0 : }
2694 : #endif
2695 :
2696 : static inline void
2697 20053828 : bbpclear(bat i, bool lock)
2698 : {
2699 20053828 : struct freebats *t = MT_thread_getfreebats();
2700 :
2701 20052109 : TRC_DEBUG(BAT, "clear %d (%s)\n", (int) i, BBP_logical(i));
2702 20052109 : BBPuncacheit(i, true);
2703 20065639 : TRC_DEBUG(BAT, "set to unloading %d\n", i);
2704 20065639 : if (lock) {
2705 20058330 : MT_lock_set(&GDKswapLock(i));
2706 : }
2707 :
2708 20059889 : BBP_status_set(i, BBPUNLOADING);
2709 20059889 : BBP_refs(i) = 0;
2710 20059889 : BBP_lrefs(i) = 0;
2711 20059889 : if (lock)
2712 20056585 : MT_lock_unset(&GDKswapLock(i));
2713 20057670 : if (!BBPtmpcheck(BBP_logical(i))) {
2714 1462 : MT_lock_set(&BBPnameLock);
2715 1462 : BBP_delete(i);
2716 1462 : MT_lock_unset(&BBPnameLock);
2717 : }
2718 20057670 : if (BBP_logical(i) != BBP_bak(i))
2719 1462 : GDKfree(BBP_logical(i));
2720 20056668 : BBP_status_set(i, 0);
2721 20056668 : BBP_logical(i) = NULL;
2722 20056668 : bat *p;
2723 58428824 : for (p = &t->freebats; *p && *p < i; p = &BBP_next(*p))
2724 : ;
2725 20056668 : BBP_next(i) = *p;
2726 20056668 : *p = i;
2727 20056668 : t->nfreebats++;
2728 20056668 : BBP_pid(i) = ~(MT_Id)0; /* not zero, not a valid thread id */
2729 20056668 : if (t->nfreebats > BBP_FREE_HIWATER) {
2730 28590 : if (lock)
2731 28590 : MT_lock_set(&GDKcacheLock);
2732 28590 : BBPhandover(t, t->nfreebats - BBP_FREE_LOWATER);
2733 28590 : if (lock)
2734 28590 : MT_lock_unset(&GDKcacheLock);
2735 : }
2736 20056668 : }
2737 :
2738 : void
2739 20056381 : BBPclear(bat i)
2740 : {
2741 20056381 : if (BBPcheck(i)) {
2742 20053801 : bool lock = locked_by == 0 || locked_by != MT_getpid();
2743 20053801 : bbpclear(i, lock);
2744 : }
2745 20054483 : }
2746 :
2747 : void
2748 49757 : BBPrelinquishbats(void)
2749 : {
2750 49757 : struct freebats *t = MT_thread_getfreebats();
2751 49757 : if (t == NULL || t->nfreebats == 0)
2752 : return;
2753 45152 : MT_lock_set(&GDKcacheLock);
2754 90306 : while (t->nfreebats > 0) {
2755 45153 : BBPhandover(t, t->nfreebats);
2756 : }
2757 45153 : MT_lock_unset(&GDKcacheLock);
2758 : }
2759 :
2760 : /*
2761 : * @- BBP rename
2762 : *
2763 : * Each BAT has a logical name that is globally unique.
2764 : * The batId is the same as the logical BAT name.
2765 : *
2766 : * The default logical name of a BAT is tmp_X, where X is the
2767 : * batCacheid. Apart from being globally unique, new logical bat
2768 : * names cannot be of the form tmp_X, unless X is the batCacheid.
2769 : *
2770 : * Physical names consist of a directory name followed by a logical
2771 : * name suffix. The directory name is derived from the batCacheid,
2772 : * and is currently organized in a hierarchy that puts max 64 bats in
2773 : * each directory (see BBPgetsubdir).
2774 : *
2775 : * Concerning the physical suffix: it is almost always bat_X. This
2776 : * saves us a whole lot of trouble, as bat_X is always unique and no
2777 : * conflicts can occur. Other suffixes are only supported in order
2778 : * just for backward compatibility with old repositories (you won't
2779 : * see them anymore in new repositories).
2780 : */
2781 : int
2782 42883 : BBPrename(BAT *b, const char *nme)
2783 : {
2784 42883 : if (b == NULL)
2785 : return 0;
2786 :
2787 42883 : bat bid = b->batCacheid;
2788 42883 : bat tmpid = 0, i;
2789 :
2790 42883 : if (nme == NULL) {
2791 15285 : if (BBP_bak(bid)[0] == 0 &&
2792 0 : snprintf(BBP_bak(bid), sizeof(BBP_bak(bid)), "tmp_%o", (unsigned) bid) >= (int) sizeof(BBP_bak(bid))) {
2793 : /* cannot happen */
2794 0 : TRC_CRITICAL(GDK, "BBP default filename too long\n");
2795 0 : return BBPRENAME_LONG;
2796 : }
2797 15285 : nme = BBP_bak(bid);
2798 : }
2799 :
2800 : /* If name stays same, do nothing */
2801 42883 : if (BBP_logical(bid) && strcmp(BBP_logical(bid), nme) == 0)
2802 : return 0;
2803 :
2804 42883 : if ((tmpid = BBPnamecheck(nme)) && tmpid != bid) {
2805 0 : GDKerror("illegal temporary name: '%s'\n", nme);
2806 0 : return BBPRENAME_ILLEGAL;
2807 : }
2808 42883 : if (strLen(nme) >= IDLENGTH) {
2809 0 : GDKerror("illegal temporary name: '%s'\n", nme);
2810 0 : return BBPRENAME_LONG;
2811 : }
2812 :
2813 42883 : MT_lock_set(&BBPnameLock);
2814 42883 : i = BBP_find(nme, false);
2815 42883 : if (i != 0) {
2816 1 : MT_lock_unset(&BBPnameLock);
2817 1 : GDKerror("name is in use: '%s'.\n", nme);
2818 1 : return BBPRENAME_ALREADY;
2819 : }
2820 :
2821 42882 : char *nnme;
2822 42882 : if (nme == BBP_bak(bid) || strcmp(nme, BBP_bak(bid)) == 0) {
2823 42882 : nnme = BBP_bak(bid);
2824 : } else {
2825 27597 : nnme = GDKstrdup(nme);
2826 27597 : if (nnme == NULL) {
2827 0 : MT_lock_unset(&BBPnameLock);
2828 0 : return BBPRENAME_MEMORY;
2829 : }
2830 : }
2831 :
2832 : /* carry through the name change */
2833 42882 : if (BBP_logical(bid) && !BBPtmpcheck(BBP_logical(bid))) {
2834 15285 : BBP_delete(bid);
2835 : }
2836 42882 : if (BBP_logical(bid) != BBP_bak(bid))
2837 15285 : GDKfree(BBP_logical(bid));
2838 42882 : BBP_logical(bid) = nnme;
2839 42882 : if (tmpid == 0) {
2840 27597 : BBP_insert(bid);
2841 : }
2842 42882 : MT_lock_set(&b->theaplock);
2843 42882 : bool transient = b->batTransient;
2844 42882 : MT_lock_unset(&b->theaplock);
2845 42882 : if (!transient) {
2846 10839 : bool lock = locked_by == 0 || locked_by != MT_getpid();
2847 :
2848 10839 : if (lock)
2849 10839 : MT_lock_set(&GDKswapLock(i));
2850 10839 : BBP_status_on(bid, BBPRENAMED);
2851 10839 : if (lock)
2852 10839 : MT_lock_unset(&GDKswapLock(i));
2853 : }
2854 42882 : MT_lock_unset(&BBPnameLock);
2855 42882 : return 0;
2856 : }
2857 :
2858 : /*
2859 : * @+ BBP swapping Policy
2860 : * The BAT can be moved back to disk using the routine BBPfree. It
2861 : * frees the storage for other BATs. After this call BAT* references
2862 : * maintained for the BAT are wrong. We should keep track of dirty
2863 : * unloaded BATs. They may have to be committed later on, which may
2864 : * include reading them in again.
2865 : *
2866 : * BBPswappable: may this bat be unloaded? Only real bats without
2867 : * memory references can be unloaded.
2868 : */
2869 : static inline void
2870 3497129 : BBPspin(bat i, const char *s, unsigned event)
2871 : {
2872 3497129 : if (BBPcheck(i) && (BBP_status(i) & event)) {
2873 : lng spin = LL_CONSTANT(0);
2874 :
2875 7213 : do {
2876 7213 : MT_sleep_ms(KITTENNAP);
2877 7213 : spin++;
2878 7213 : } while (BBP_status(i) & event);
2879 131 : TRC_DEBUG(BAT, "%d,%s,%u: " LLFMT " loops\n", (int) i, s, event, spin);
2880 : }
2881 3496912 : }
2882 :
2883 : void
2884 7604552 : BBPcold(bat i)
2885 : {
2886 7604552 : if (!is_bat_nil(i)) {
2887 7604666 : BAT *b = BBP_desc(i);
2888 7604666 : if (b->batRole == PERSISTENT)
2889 701 : BBP_status_off(i, BBPHOT);
2890 : }
2891 7604552 : }
2892 :
2893 : /* This function can fail if the input parameter (i) is incorrect
2894 : * (unlikely). */
2895 : static inline int
2896 121342866 : incref(bat i, bool logical, bool lock)
2897 : {
2898 121342866 : int refs;
2899 121342866 : BAT *b;
2900 :
2901 121342866 : if (!BBPcheck(i))
2902 : return 0;
2903 :
2904 121267129 : if (lock) {
2905 36860092 : for (;;) {
2906 36860092 : MT_lock_set(&GDKswapLock(i));
2907 36987202 : if (!(BBP_status(i) & (BBPUNSTABLE|BBPLOADING)))
2908 : break;
2909 : /* the BATs is "unstable", try again */
2910 0 : MT_lock_unset(&GDKswapLock(i));
2911 0 : BBPspin(i, __func__, BBPUNSTABLE|BBPLOADING);
2912 : }
2913 : }
2914 : /* we have the lock */
2915 :
2916 121394239 : b = BBP_desc(i);
2917 121394239 : if (b->batCacheid == 0) {
2918 : /* should not have happened */
2919 0 : if (lock)
2920 0 : MT_lock_unset(&GDKswapLock(i));
2921 0 : return 0;
2922 : }
2923 :
2924 121394239 : assert(BBP_refs(i) + BBP_lrefs(i) ||
2925 : BBP_status(i) & (BBPDELETED | BBPSWAPPED));
2926 121394239 : if (logical) {
2927 36867227 : refs = ++BBP_lrefs(i);
2928 36867227 : BBP_pid(i) = 0;
2929 : } else {
2930 84527012 : refs = ++BBP_refs(i);
2931 84527012 : BBP_status_on(i, BBPHOT);
2932 : }
2933 121394239 : if (lock)
2934 36866151 : MT_lock_unset(&GDKswapLock(i));
2935 :
2936 : return refs;
2937 : }
2938 :
2939 : /* increment the physical reference counter for the given bat
2940 : * returns the new reference count
2941 : * also increments the physical reference count of the parent bat(s) (if
2942 : * any) */
2943 : int
2944 68445 : BBPfix(bat i)
2945 : {
2946 68445 : return BATdescriptor(i) ? 1 : 0;
2947 : }
2948 :
2949 : /* increment the logical reference count for the given bat
2950 : * returns the new reference count */
2951 : int
2952 31171210 : BBPretain(bat i)
2953 : {
2954 31171210 : bool lock = locked_by == 0 || locked_by != MT_getpid();
2955 :
2956 31171210 : return incref(i, true, lock);
2957 : }
2958 :
2959 : static inline int
2960 149775682 : decref(bat i, bool logical, bool lock, const char *func)
2961 : {
2962 149775682 : int refs = 0, lrefs;
2963 149775682 : bool swap = false;
2964 149775682 : bool locked = false;
2965 149775682 : int farmid = 0;
2966 149775682 : BAT *b;
2967 :
2968 149775682 : if (is_bat_nil(i))
2969 : return -1;
2970 140995094 : assert(i > 0);
2971 140995094 : if (BBPcheck(i) == 0)
2972 : return -1;
2973 :
2974 140879306 : if (lock)
2975 140880487 : MT_lock_set(&GDKswapLock(i));
2976 :
2977 140757938 : while (BBP_status(i) & BBPUNLOADING) {
2978 0 : if (lock)
2979 0 : MT_lock_unset(&GDKswapLock(i));
2980 0 : BBPspin(i, func, BBPUNLOADING);
2981 0 : if (lock)
2982 140757938 : MT_lock_set(&GDKswapLock(i));
2983 : }
2984 :
2985 140886797 : b = (BBP_status(i) & BBPLOADED) ? BBP_desc(i) : NULL;
2986 :
2987 : /* decrement references by one */
2988 140886797 : if (logical) {
2989 36788179 : if (BBP_lrefs(i) == 0) {
2990 0 : GDKerror("%s: %s does not have logical references.\n", func, BBP_logical(i));
2991 0 : assert(0);
2992 : } else {
2993 36788179 : refs = --BBP_lrefs(i);
2994 : }
2995 : /* cannot release last logical ref if still shared */
2996 : // but we could still have a bat iterator on it
2997 : //assert(!BATshared(BBP_desc(i)) || refs > 0);
2998 : } else {
2999 104098618 : if (BBP_refs(i) == 0) {
3000 0 : GDKerror("%s: %s does not have pointer fixes.\n", func, BBP_logical(i));
3001 0 : assert(0);
3002 : } else {
3003 104098618 : refs = --BBP_refs(i);
3004 104098618 : if (b && refs == 0) {
3005 85102392 : MT_lock_set(&b->theaplock);
3006 85194860 : locked = true;
3007 85194860 : if (VIEWtparent(b) || VIEWvtparent(b))
3008 15306159 : BBP_status_on(i, BBPHOT);
3009 : }
3010 : }
3011 : }
3012 140979265 : if (b) {
3013 140731899 : if (!locked) {
3014 55802668 : MT_lock_set(&b->theaplock);
3015 55836798 : locked = true;
3016 : }
3017 140738216 : if (b->theap)
3018 140738216 : farmid = b->theap->farmid;
3019 : }
3020 :
3021 : /* we destroy transients asap and unload persistent bats only
3022 : * if they have been made cold or are not dirty */
3023 140985582 : unsigned chkflag = BBPSYNCING;
3024 140985582 : bool swapdirty = false;
3025 140985582 : if (b) {
3026 140757843 : size_t cursize;
3027 140757843 : if ((cursize = GDKvm_cursize()) < (size_t) (GDK_vm_maxsize * 0.75)) {
3028 140772798 : if (!locked) {
3029 0 : MT_lock_set(&b->theaplock);
3030 0 : locked = true;
3031 : }
3032 140772798 : if (((b->theap ? b->theap->size : 0) + (b->tvheap ? b->tvheap->size : 0)) < (GDK_vm_maxsize - cursize) / 32)
3033 140770697 : chkflag |= BBPHOT;
3034 0 : } else if (cursize > (size_t) (GDK_vm_maxsize * 0.85))
3035 141000537 : swapdirty = true;
3036 : }
3037 : /* only consider unloading if refs is 0; if, in addition, lrefs
3038 : * is 0, we can definitely unload, else only if some more
3039 : * conditions are met */
3040 241415967 : if (BBP_refs(i) == 0 &&
3041 120464134 : (BBP_lrefs(i) == 0 ||
3042 100380826 : (b != NULL && b->theap != NULL
3043 100383249 : ? ((swapdirty || !BATdirty(b)) &&
3044 13069795 : !(BBP_status(i) & chkflag) &&
3045 16288 : (BBP_status(i) & BBPPERSISTENT) &&
3046 : /* cannot unload in-memory data */
3047 7873 : !GDKinmemory(farmid) &&
3048 : /* do not unload views or parents of views */
3049 7873 : !BATshared(b) &&
3050 100388050 : b->batCacheid == b->theap->parentid &&
3051 7224 : (b->tvheap == NULL || b->batCacheid == b->tvheap->parentid))
3052 34604 : : (BBP_status(i) & BBPTMP)))) {
3053 : /* bat will be unloaded now. set the UNLOADING bit
3054 : * while locked so no other thread thinks it's
3055 : * available anymore */
3056 20061589 : assert((BBP_status(i) & BBPUNLOADING) == 0);
3057 20061589 : TRC_DEBUG(BAT, "%s set to unloading BAT %d (status %u, lrefs %d)\n", func, i, BBP_status(i), BBP_lrefs(i));
3058 20061589 : BBP_status_on(i, BBPUNLOADING);
3059 20061589 : swap = true;
3060 : } /* else: bat cannot be swapped out */
3061 141000537 : lrefs = BBP_lrefs(i);
3062 141000537 : if (locked)
3063 140779363 : MT_lock_unset(&b->theaplock);
3064 :
3065 : /* unlock before re-locking in unload; as saving a dirty
3066 : * persistent bat may take a long time */
3067 140919572 : if (lock)
3068 140732164 : MT_lock_unset(&GDKswapLock(i));
3069 :
3070 141288713 : if (swap) {
3071 20069901 : if (b != NULL) {
3072 20050209 : if (lrefs == 0 && (BBP_status(i) & BBPDELETED) == 0) {
3073 : /* free memory (if loaded) and delete from
3074 : * disk (if transient but saved) */
3075 20042931 : BBPdestroy(b);
3076 : } else {
3077 7278 : TRC_DEBUG(BAT, "%s unload and free bat %d\n", func, i);
3078 : /* free memory of transient */
3079 7278 : if (BBPfree(b) != GDK_SUCCEED)
3080 : return -1; /* indicate failure */
3081 : }
3082 19692 : } else if (lrefs == 0 && (BBP_status(i) & BBPDELETED) == 0) {
3083 13711 : BATdelete(BBP_desc(i));
3084 13711 : BBPclear(i);
3085 : } else {
3086 5981 : BBP_status_off(i, BBPUNLOADING);
3087 : }
3088 : }
3089 : return refs;
3090 : }
3091 :
3092 : int
3093 99927880 : BBPunfix(bat i)
3094 : {
3095 99927880 : return decref(i, false, true, __func__);
3096 : }
3097 :
3098 : int
3099 45576709 : BBPrelease(bat i)
3100 : {
3101 45576709 : return decref(i, true, true, __func__);
3102 : }
3103 :
3104 : void
3105 5708067 : BBPkeepref(BAT *b)
3106 : {
3107 5708067 : assert(b != NULL);
3108 5708067 : bool lock = locked_by == 0 || locked_by != MT_getpid();
3109 5708067 : int i = b->batCacheid;
3110 5708067 : int refs = incref(i, true, lock);
3111 5708166 : if (refs == 1) {
3112 5413664 : MT_lock_set(&b->theaplock);
3113 5410147 : BATsettrivprop(b);
3114 5406954 : MT_lock_unset(&b->theaplock);
3115 : }
3116 5700394 : if (ATOMIC_GET(&GDKdebug) & CHECKMASK)
3117 5698194 : BATassertProps(b);
3118 5706503 : if (BATsetaccess(b, BAT_READ) == NULL)
3119 : return; /* already decreffed */
3120 :
3121 4377116 : refs = decref(i, false, lock, __func__);
3122 4378030 : (void) refs;
3123 4378030 : assert(refs >= 0);
3124 : }
3125 :
3126 : BAT *
3127 84665213 : BATdescriptor(bat i)
3128 : {
3129 84665213 : BAT *b = NULL;
3130 :
3131 84665213 : if (BBPcheck(i)) {
3132 84578247 : bool lock = locked_by == 0 || locked_by != MT_getpid();
3133 : if (lock) {
3134 84578247 : for (;;) {
3135 84578247 : MT_lock_set(&GDKswapLock(i));
3136 84554155 : if (!(BBP_status(i) & (BBPUNSTABLE|BBPLOADING)))
3137 : break;
3138 : /* the BATs is "unstable", try again */
3139 0 : MT_lock_unset(&GDKswapLock(i));
3140 0 : BBPspin(i, __func__, BBPUNSTABLE|BBPLOADING);
3141 : }
3142 : }
3143 84554155 : if (incref(i, false, false) > 0) {
3144 84709054 : if ((BBP_status(i) & BBPLOADED) == 0) {
3145 24126 : b = getBBPdescriptor(i);
3146 24126 : if (b == NULL) {
3147 : /* if loading failed, we need to
3148 : * compensate for the incref */
3149 0 : decref(i, false, false, __func__);
3150 : }
3151 : } else {
3152 84684928 : b = BBP_desc(i);
3153 : }
3154 : }
3155 84709054 : if (lock)
3156 84690586 : MT_lock_unset(&GDKswapLock(i));
3157 : }
3158 84603660 : return b;
3159 : }
3160 :
3161 : /*
3162 : * BBPdescriptor checks whether BAT needs loading and does so if
3163 : * necessary. You must have at least one fix on the BAT before calling
3164 : * this.
3165 : */
3166 : static BAT *
3167 24126 : getBBPdescriptor(bat i)
3168 : {
3169 24126 : bool load = false;
3170 24126 : BAT *b = NULL;
3171 :
3172 24126 : assert(i > 0);
3173 24126 : if (!BBPcheck(i)) {
3174 0 : GDKerror("BBPcheck failed for bat id %d\n", i);
3175 0 : return NULL;
3176 : }
3177 24126 : assert(BBP_refs(i));
3178 24126 : unsigned status = BBP_status(i);
3179 24126 : b = BBP_desc(i);
3180 24126 : if ((status & BBPLOADED) == 0 || status & BBPWAITING) {
3181 24126 : while (BBP_status(i) & BBPWAITING) { /* wait for bat to be loaded by other thread */
3182 0 : MT_lock_unset(&GDKswapLock(i));
3183 0 : BBPspin(i, __func__, BBPWAITING);
3184 24126 : MT_lock_set(&GDKswapLock(i));
3185 : }
3186 24126 : if (BBPvalid(i)) {
3187 24126 : if ((BBP_status(i) & BBPLOADED) == 0) {
3188 24126 : load = true;
3189 24126 : TRC_DEBUG(BAT, "set to loading BAT %d\n", i);
3190 24126 : BBP_status_on(i, BBPLOADING);
3191 : }
3192 : }
3193 : }
3194 24126 : if (load) {
3195 24126 : TRC_DEBUG(IO, "load %s\n", BBP_logical(i));
3196 :
3197 24126 : b = BATload_intern(i, false);
3198 :
3199 24126 : BBP_status_off(i, BBPLOADING);
3200 24126 : CHECKDEBUG if (b != NULL)
3201 22588 : BATassertProps(b);
3202 : }
3203 : return b;
3204 : }
3205 :
3206 : /*
3207 : * In BBPsave executes unlocked; it just marks the BBP_status of the
3208 : * BAT to BBPsaving, so others that want to save or unload this BAT
3209 : * must spin lock on the BBP_status field.
3210 : */
3211 : gdk_return
3212 19655 : BBPsave(BAT *b)
3213 : {
3214 19655 : bool lock = locked_by == 0 || locked_by != MT_getpid();
3215 19655 : bat bid = b->batCacheid;
3216 19655 : gdk_return ret = GDK_SUCCEED;
3217 :
3218 19655 : MT_lock_set(&b->theaplock);
3219 19655 : if (BBP_lrefs(bid) == 0 || isVIEW(b) || !BATdirty(b)) {
3220 : /* do nothing */
3221 11445 : MT_lock_unset(&b->theaplock);
3222 11445 : MT_rwlock_rdlock(&b->thashlock);
3223 11445 : if (b->thash && b->thash != (Hash *) 1 &&
3224 252 : (b->thash->heaplink.dirty || b->thash->heapbckt.dirty))
3225 132 : BAThashsave(b, (BBP_status(bid) & BBPPERSISTENT) != 0);
3226 11445 : MT_rwlock_rdunlock(&b->thashlock);
3227 11445 : return GDK_SUCCEED;
3228 : }
3229 8210 : MT_lock_unset(&b->theaplock);
3230 8210 : if (lock)
3231 8210 : MT_lock_set(&GDKswapLock(bid));
3232 :
3233 8210 : if (BBP_status(bid) & BBPSAVING) {
3234 : /* wait until save in other thread completes */
3235 0 : if (lock)
3236 0 : MT_lock_unset(&GDKswapLock(bid));
3237 0 : BBPspin(bid, __func__, BBPSAVING);
3238 : } else {
3239 : /* save it */
3240 8210 : unsigned flags = BBPSAVING;
3241 :
3242 8210 : MT_lock_set(&b->theaplock);
3243 8210 : if (DELTAdirty(b)) {
3244 89 : flags |= BBPSWAPPED;
3245 : }
3246 8210 : if (b->batTransient) {
3247 8205 : flags |= BBPTMP;
3248 : }
3249 8210 : MT_lock_unset(&b->theaplock);
3250 8210 : BBP_status_on(bid, flags);
3251 8210 : if (lock)
3252 8210 : MT_lock_unset(&GDKswapLock(bid));
3253 :
3254 8210 : TRC_DEBUG(IO, "save " ALGOBATFMT "\n", ALGOBATPAR(b));
3255 :
3256 : /* do the time-consuming work unlocked */
3257 8210 : if (BBP_status(bid) & BBPEXISTING && b->batInserted > 0)
3258 2 : ret = BBPbackup(b, false);
3259 2 : if (ret == GDK_SUCCEED) {
3260 8210 : ret = BATsave(b);
3261 : }
3262 : /* clearing bits can be done without the lock */
3263 8210 : BBP_status_off(bid, BBPSAVING);
3264 : }
3265 : return ret;
3266 : }
3267 :
3268 : /*
3269 : * TODO merge BBPfree with BATfree? Its function is to prepare a BAT
3270 : * for being unloaded (or even destroyed, if the BAT is not
3271 : * persistent).
3272 : */
3273 : static void
3274 20042660 : BBPdestroy(BAT *b)
3275 : {
3276 20042660 : bat tp = VIEWtparent(b);
3277 20042660 : bat vtp = VIEWvtparent(b);
3278 :
3279 20042660 : if (b->theap) {
3280 20042495 : HEAPdecref(b->theap, tp == 0);
3281 20042497 : b->theap = NULL;
3282 20042497 : if (tp != 0)
3283 10635240 : BBPrelease(tp);
3284 : }
3285 20043746 : if (b->tvheap) {
3286 3359108 : HEAPdecref(b->tvheap, vtp == 0);
3287 3359109 : b->tvheap = NULL;
3288 3359109 : if (vtp != 0)
3289 2481574 : BBPrelease(vtp);
3290 : }
3291 20043754 : if (b->oldtail) {
3292 2 : ATOMIC_AND(&b->oldtail->refs, ~DELAYEDREMOVE);
3293 2 : HEAPdecref(b->oldtail, true);
3294 2 : b->oldtail = NULL;
3295 : }
3296 20043754 : BATdelete(b);
3297 :
3298 20041831 : BBPclear(b->batCacheid); /* if destroyed; de-register from BBP */
3299 20040263 : }
3300 :
3301 : static gdk_return
3302 19655 : BBPfree(BAT *b)
3303 : {
3304 19655 : bat bid = b->batCacheid;
3305 19655 : gdk_return ret;
3306 :
3307 19655 : assert(bid > 0);
3308 19655 : assert(BBPswappable(b));
3309 19655 : assert(!isVIEW(b));
3310 :
3311 19655 : BBP_unload_inc();
3312 : /* write dirty BATs before unloading */
3313 19655 : ret = BBPsave(b);
3314 19655 : if (ret == GDK_SUCCEED) {
3315 19655 : if (BBP_status(bid) & BBPLOADED)
3316 19655 : BATfree(b); /* free memory */
3317 19655 : BBPuncacheit(bid, false);
3318 : }
3319 19655 : TRC_DEBUG(BAT, "turn off unloading %d\n", bid);
3320 19655 : BBP_status_off(bid, BBPUNLOADING);
3321 19655 : BBP_unload_dec();
3322 19655 : return ret;
3323 : }
3324 :
3325 : /*
3326 : * BBPquickdesc loads a BAT descriptor without loading the entire BAT,
3327 : * of which the result be used only for a *limited* number of
3328 : * purposes. Specifically, during the global sync/commit, we do not
3329 : * want to load any BATs that are not already loaded, both because
3330 : * this costs performance, and because getting into memory shortage
3331 : * during a commit is extremely dangerous. Loading a BAT tends not to
3332 : * be required, since the commit actions mostly involve moving some
3333 : * pointers in the BAT descriptor.
3334 : */
3335 : BAT *
3336 1421864 : BBPquickdesc(bat bid)
3337 : {
3338 1421864 : BAT *b;
3339 :
3340 1421864 : if (!BBPcheck(bid)) {
3341 163 : if (!is_bat_nil(bid)) {
3342 0 : GDKerror("called with invalid batid.\n");
3343 0 : assert(0);
3344 : }
3345 : return NULL;
3346 : }
3347 1421452 : BBPspin(bid, __func__, BBPWAITING);
3348 1421264 : b = BBP_desc(bid);
3349 1421264 : if (b->ttype < 0) {
3350 241 : const char *aname = ATOMunknown_name(b->ttype);
3351 241 : int tt = ATOMindex(aname);
3352 241 : if (tt < 0) {
3353 0 : GDKwarning("atom '%s' unknown in bat '%s'.\n",
3354 : aname, BBP_physical(bid));
3355 : } else {
3356 241 : b->ttype = tt;
3357 : }
3358 : }
3359 : return b;
3360 : }
3361 :
3362 : /*
3363 : * @+ Global Commit
3364 : */
3365 : static BAT *
3366 2084231 : dirty_bat(bat *i, bool subcommit)
3367 : {
3368 2084231 : if (BBPvalid(*i)) {
3369 2075706 : BAT *b;
3370 2075706 : BBPspin(*i, __func__, BBPSAVING);
3371 2075706 : if (BBP_status(*i) & BBPLOADED) {
3372 1930609 : b = BBP_desc(*i);
3373 1930609 : MT_lock_set(&b->theaplock);
3374 2075679 : if ((BBP_status(*i) & BBPNEW) &&
3375 145070 : BATcheckmodes(b, false) != GDK_SUCCEED) /* check mmap modes */
3376 0 : *i = -*i; /* error */
3377 1930609 : else if ((BBP_status(*i) & BBPPERSISTENT) &&
3378 0 : (subcommit || BATdirty(b))) {
3379 1749940 : MT_lock_unset(&b->theaplock);
3380 1749940 : return b; /* the bat is loaded, persistent and dirty */
3381 : }
3382 180669 : MT_lock_unset(&b->theaplock);
3383 145097 : } else if (subcommit)
3384 142563 : return BBP_desc(*i);
3385 : }
3386 : return NULL;
3387 : }
3388 :
3389 : /*
3390 : * @- backup-bat
3391 : * Backup-bat moves all files of a BAT to a backup directory. Only
3392 : * after this succeeds, it may be saved. If some failure occurs
3393 : * halfway saving, we can thus always roll back.
3394 : */
3395 : static gdk_return
3396 226992 : file_move(int farmid, const char *srcdir, const char *dstdir, const char *name, const char *ext)
3397 : {
3398 226992 : if (GDKmove(farmid, srcdir, name, ext, dstdir, name, ext, false) == GDK_SUCCEED) {
3399 : return GDK_SUCCEED;
3400 : } else {
3401 0 : char path[MAXPATH];
3402 0 : struct stat st;
3403 :
3404 0 : if (GDKfilepath(path, sizeof(path), farmid, srcdir, name, ext) != GDK_SUCCEED)
3405 0 : return GDK_FAIL;
3406 0 : if (MT_stat(path, &st)) {
3407 : /* source file does not exist; the best
3408 : * recovery is to give an error but continue
3409 : * by considering the BAT as not saved; making
3410 : * sure that this time it does get saved.
3411 : */
3412 0 : GDKsyserror("file_move: cannot stat %s\n", path);
3413 0 : return GDK_FAIL; /* fishy, but not fatal */
3414 : }
3415 : }
3416 0 : return GDK_FAIL;
3417 : }
3418 :
3419 : /* returns true if the file exists */
3420 : static bool
3421 3315440 : file_exists(int farmid, const char *dir, const char *name, const char *ext)
3422 : {
3423 3315440 : char path[MAXPATH];
3424 3315440 : struct stat st;
3425 3315440 : int ret = -1;
3426 :
3427 3315440 : if (GDKfilepath(path, sizeof(path), farmid, dir, name, ext) == GDK_SUCCEED) {
3428 3315440 : ret = MT_stat(path, &st);
3429 3315440 : TRC_DEBUG(IO, "stat(%s) = %d\n", path, ret);
3430 : }
3431 3315440 : return (ret == 0);
3432 : }
3433 :
3434 : static gdk_return
3435 226992 : heap_move(Heap *hp, const char *srcdir, const char *dstdir, const char *nme, const char *ext)
3436 : {
3437 : /* see doc at BATsetaccess()/gdk_bat.c for an expose on mmap
3438 : * heap modes */
3439 226992 : if (file_exists(hp->farmid, dstdir, nme, ext)) {
3440 : /* dont overwrite heap with the committed state
3441 : * already in dstdir */
3442 : return GDK_SUCCEED;
3443 226992 : } else if (hp->newstorage == STORE_PRIV &&
3444 0 : !file_exists(hp->farmid, srcdir, nme, ext)) {
3445 :
3446 : /* In order to prevent half-saved X.new files
3447 : * surviving a recover we create a dummy file in the
3448 : * BACKUP(dstdir) whose presence will trigger
3449 : * BBPrecover to remove them. Thus, X will prevail
3450 : * where it otherwise wouldn't have. If X already has
3451 : * a saved X.new, that one is backed up as normal.
3452 : */
3453 :
3454 0 : FILE *fp;
3455 0 : long_str kill_ext;
3456 0 : char path[MAXPATH];
3457 :
3458 0 : strconcat_len(kill_ext, sizeof(kill_ext), ext, ".kill", NULL);
3459 0 : if (GDKfilepath(path, sizeof(path), hp->farmid, dstdir, nme, kill_ext) != GDK_SUCCEED)
3460 : return GDK_FAIL;
3461 0 : fp = MT_fopen(path, "w");
3462 0 : if (fp == NULL)
3463 0 : GDKsyserror("heap_move: cannot open file %s\n", path);
3464 0 : TRC_DEBUG(IO, "open %s = %d\n", path, fp ? 0 : -1);
3465 :
3466 0 : if (fp != NULL) {
3467 0 : fclose(fp);
3468 0 : return GDK_SUCCEED;
3469 : } else {
3470 : return GDK_FAIL;
3471 : }
3472 : }
3473 226992 : return file_move(hp->farmid, srcdir, dstdir, nme, ext);
3474 : }
3475 :
3476 : /*
3477 : * @- BBPprepare
3478 : *
3479 : * this routine makes sure there is a BAKDIR/, and initiates one if
3480 : * not. For subcommits, it does the same with SUBDIR.
3481 : *
3482 : * It is now locked, to get proper file counters, and also to prevent
3483 : * concurrent BBPrecovers, etc.
3484 : *
3485 : * backup_dir == 0 => no backup BBP.dir
3486 : * backup_dir == 1 => BBP.dir saved in BACKUP/
3487 : * backup_dir == 2 => BBP.dir saved in SUBCOMMIT/
3488 : */
3489 :
3490 : static gdk_return
3491 27016 : BBPprepare(bool subcommit)
3492 : {
3493 27016 : bool start_subcommit;
3494 27016 : int set = 1 + subcommit;
3495 27016 : gdk_return ret = GDK_SUCCEED;
3496 :
3497 27016 : start_subcommit = (subcommit && backup_subdir == 0);
3498 13322 : if (start_subcommit) {
3499 : /* starting a subcommit. Make sure SUBDIR and DELDIR
3500 : * are clean */
3501 13322 : ret = BBPrecover_subdir();
3502 13322 : if (ret != GDK_SUCCEED)
3503 : return ret;
3504 : }
3505 27016 : if (backup_files == 0) {
3506 364 : backup_dir = 0;
3507 364 : ret = BBPrecover(0);
3508 364 : if (ret != GDK_SUCCEED)
3509 0 : return ret;
3510 364 : char bakdirpath[MAXPATH];
3511 :
3512 364 : if (GDKfilepath(bakdirpath, sizeof(bakdirpath), 0, NULL, BAKDIR, NULL) != GDK_SUCCEED) {
3513 : return GDK_FAIL;
3514 : }
3515 :
3516 364 : if (MT_mkdir(bakdirpath) < 0 && errno != EEXIST) {
3517 0 : GDKsyserror("cannot create directory %s\n", bakdirpath);
3518 0 : return GDK_FAIL;
3519 : }
3520 : /* if BAKDIR already exists, don't signal error */
3521 364 : TRC_DEBUG(IO, "mkdir %s = %d\n", bakdirpath, (int) ret);
3522 : }
3523 27016 : if (start_subcommit) {
3524 : /* make a new SUBDIR (subdir of BAKDIR) */
3525 13322 : char subdirpath[MAXPATH];
3526 :
3527 13322 : if (GDKfilepath(subdirpath, sizeof(subdirpath), 0, NULL, SUBDIR, NULL) != GDK_SUCCEED) {
3528 0 : return GDK_FAIL;
3529 : }
3530 :
3531 13322 : if (MT_mkdir(subdirpath) < 0) {
3532 0 : GDKsyserror("cannot create directory %s\n", subdirpath);
3533 0 : return GDK_FAIL;
3534 : }
3535 13322 : TRC_DEBUG(IO, "mkdir %s\n", subdirpath);
3536 : }
3537 27016 : if (backup_dir != set) {
3538 : /* a valid backup dir *must* at least contain BBP.dir */
3539 54380 : if ((ret = GDKmove(0, backup_dir ? BAKDIR : BATDIR, "BBP", "dir", subcommit ? SUBDIR : BAKDIR, "BBP", "dir", true)) != GDK_SUCCEED)
3540 : return ret;
3541 27008 : backup_dir = set;
3542 : }
3543 : /* increase counters */
3544 27016 : backup_subdir += subcommit;
3545 27016 : backup_files++;
3546 :
3547 27016 : return ret;
3548 : }
3549 :
3550 : static gdk_return
3551 1328079 : do_backup(Heap *h, bool dirty, bool subcommit)
3552 : {
3553 1328079 : gdk_return ret = GDK_SUCCEED;
3554 1328079 : char extnew[16];
3555 :
3556 1328079 : if (h->wasempty) {
3557 : return GDK_SUCCEED;
3558 : }
3559 :
3560 : /* direct mmap is unprotected (readonly usage, or has WAL
3561 : * protection) */
3562 1328079 : if (h->storage != STORE_MMAP) {
3563 : /* STORE_PRIV saves into X.new files. Two cases could
3564 : * happen. The first is when a valid X.new exists
3565 : * because of an access change or a previous
3566 : * commit. This X.new should be backed up as
3567 : * usual. The second case is when X.new doesn't
3568 : * exist. In that case we could have half written
3569 : * X.new files (after a crash). To protect against
3570 : * these we write X.new.kill files in the backup
3571 : * directory (see heap_move). */
3572 1317232 : gdk_return mvret = GDK_SUCCEED;
3573 1317232 : char srcdir[1025];
3574 :
3575 1317232 : if (GDKfilepath(srcdir, sizeof(srcdir), NOFARM, BATDIR, h->filename, NULL) != GDK_SUCCEED)
3576 0 : return GDK_FAIL;
3577 1317232 : char *nme = strrchr(srcdir, DIR_SEP);
3578 1317232 : assert(nme != NULL);
3579 1317232 : *nme++ = '\0';
3580 1317232 : char *ext = strchr(nme, '.');
3581 1317232 : assert(ext != NULL);
3582 1317232 : *ext++ = '\0';
3583 :
3584 1317232 : strconcat_len(extnew, sizeof(extnew), ext, ".new", NULL);
3585 1544224 : if (dirty &&
3586 453984 : !file_exists(h->farmid, BAKDIR, nme, extnew) &&
3587 226992 : !file_exists(h->farmid, BAKDIR, nme, ext)) {
3588 : /* if the heap is dirty and there is no heap
3589 : * file (with or without .new extension) in
3590 : * the BAKDIR, move the heap (preferably with
3591 : * .new extension) to the correct backup
3592 : * directory */
3593 226992 : if (file_exists(h->farmid, srcdir, nme, extnew)) {
3594 0 : mvret = heap_move(h, srcdir,
3595 : subcommit ? SUBDIR : BAKDIR,
3596 : nme, extnew);
3597 226992 : } else if (file_exists(h->farmid, srcdir, nme, ext)) {
3598 226994 : mvret = heap_move(h, srcdir,
3599 : subcommit ? SUBDIR : BAKDIR,
3600 : nme, ext);
3601 226992 : if (mvret == GDK_SUCCEED) {
3602 : /* file no longer in "standard"
3603 : * location */
3604 226992 : h->hasfile = false;
3605 : }
3606 : }
3607 1090240 : } else if (subcommit) {
3608 : /* if subcommit, we may need to move an
3609 : * already made backup from BAKDIR to
3610 : * SUBDIR */
3611 1090240 : if (file_exists(h->farmid, BAKDIR, nme, extnew))
3612 0 : mvret = file_move(h->farmid, BAKDIR, SUBDIR, nme, extnew);
3613 1090240 : else if (file_exists(h->farmid, BAKDIR, nme, ext))
3614 0 : mvret = file_move(h->farmid, BAKDIR, SUBDIR, nme, ext);
3615 : }
3616 : /* there is a situation where the move may fail,
3617 : * namely if this heap was not supposed to be existing
3618 : * before, i.e. after a BATmaterialize on a persistent
3619 : * bat; as a workaround, do not complain about move
3620 : * failure if the source file is nonexistent
3621 : */
3622 226992 : if (mvret != GDK_SUCCEED && file_exists(h->farmid, srcdir, nme, ext)) {
3623 1317232 : ret = GDK_FAIL;
3624 : }
3625 1317232 : if (subcommit &&
3626 1317230 : (h->storage == STORE_PRIV || h->newstorage == STORE_PRIV)) {
3627 0 : long_str kill_ext;
3628 :
3629 0 : strconcat_len(kill_ext, sizeof(kill_ext),
3630 : ext, ".new.kill", NULL);
3631 0 : if (file_exists(h->farmid, BAKDIR, nme, kill_ext) &&
3632 0 : file_move(h->farmid, BAKDIR, SUBDIR, nme, kill_ext) != GDK_SUCCEED) {
3633 0 : ret = GDK_FAIL;
3634 : }
3635 : }
3636 : }
3637 : return ret;
3638 : }
3639 :
3640 : static gdk_return
3641 1051747 : BBPbackup(BAT *b, bool subcommit)
3642 : {
3643 1051747 : gdk_return rc = GDK_SUCCEED;
3644 :
3645 1051747 : MT_lock_set(&b->theaplock);
3646 1051747 : BATiter bi = bat_iterator_nolock(b);
3647 1051747 : if (!bi.copiedtodisk || bi.transient) {
3648 1 : MT_lock_unset(&b->theaplock);
3649 1 : return GDK_SUCCEED;
3650 : }
3651 1051746 : assert(b->theap->parentid == b->batCacheid);
3652 1051746 : if (b->oldtail && b->oldtail != (Heap *) 1) {
3653 1745 : bi.h = b->oldtail;
3654 1745 : bi.hdirty = b->oldtail->dirty;
3655 : }
3656 1051746 : bat_iterator_incref(&bi);
3657 1051746 : MT_lock_unset(&b->theaplock);
3658 :
3659 : /* determine location dir and physical suffix */
3660 1051746 : if (bi.type != TYPE_void) {
3661 1051746 : rc = do_backup(bi.h, bi.hdirty, subcommit);
3662 1051746 : if (rc == GDK_SUCCEED && bi.vh != NULL)
3663 276333 : rc = do_backup(bi.vh, bi.vhdirty, subcommit);
3664 : }
3665 1051746 : bat_iterator_end(&bi);
3666 1051746 : return rc;
3667 : }
3668 :
3669 : static inline void
3670 0 : BBPcheckHeap(Heap *h)
3671 : {
3672 0 : struct stat statb;
3673 0 : char path[MAXPATH];
3674 :
3675 0 : char *s = strrchr(h->filename, DIR_SEP);
3676 0 : if (s)
3677 0 : s++;
3678 : else
3679 : s = h->filename;
3680 0 : if (GDKfilepath(path, sizeof(path), 0, BAKDIR, s, NULL) != GDK_SUCCEED)
3681 0 : return;
3682 0 : if (MT_stat(path, &statb) < 0) {
3683 0 : if (GDKfilepath(path, sizeof(path), 0, BATDIR, h->filename, NULL) != GDK_SUCCEED)
3684 : return;
3685 0 : if (MT_stat(path, &statb) < 0) {
3686 0 : GDKsyserror("cannot stat file %s (expected size %zu)\n",
3687 : path, h->free);
3688 0 : assert(0);
3689 : return;
3690 : }
3691 : }
3692 0 : assert((statb.st_mode & S_IFMT) == S_IFREG);
3693 0 : assert((size_t) statb.st_size >= h->free);
3694 0 : if ((size_t) statb.st_size < h->free) {
3695 : GDKerror("file %s too small (expected %zu, actual %zu)\n", path, h->free, (size_t) statb.st_size);
3696 : return;
3697 : }
3698 : }
3699 :
3700 : static void
3701 0 : BBPcheckBBPdir(void)
3702 : {
3703 0 : FILE *fp;
3704 0 : int lineno = 0;
3705 0 : bat bbpsize = 0;
3706 0 : unsigned bbpversion;
3707 0 : lng logno;
3708 :
3709 0 : fp = GDKfileopen(0, BAKDIR, "BBP", "dir", "r");
3710 0 : assert(fp != NULL);
3711 0 : if (fp == NULL) {
3712 : fp = GDKfileopen(0, BATDIR, "BBP", "dir", "r");
3713 : assert(fp != NULL);
3714 : if (fp == NULL)
3715 : return;
3716 : }
3717 0 : bbpversion = BBPheader(fp, &lineno, &bbpsize, &logno, false);
3718 0 : if (bbpversion == 0) {
3719 0 : fclose(fp);
3720 0 : return; /* error reading file */
3721 : }
3722 0 : assert(bbpversion == GDKLIBRARY);
3723 :
3724 0 : for (;;) {
3725 0 : BAT b;
3726 0 : Heap h;
3727 0 : Heap vh;
3728 0 : vh = h = (Heap) {
3729 : .free = 0,
3730 : };
3731 0 : b = (BAT) {
3732 : .theap = &h,
3733 : .tvheap = &vh,
3734 : };
3735 0 : char filename[sizeof(BBP_physical(0))];
3736 0 : char batname[129];
3737 : #ifdef GDKLIBRARY_HASHASH
3738 0 : int hashash;
3739 : #endif
3740 :
3741 0 : switch (BBPreadBBPline(fp, bbpversion, &lineno, &b,
3742 : #ifdef GDKLIBRARY_HASHASH
3743 : &hashash,
3744 : #endif
3745 : batname, filename, NULL)) {
3746 0 : case 0:
3747 : /* end of file */
3748 0 : fclose(fp);
3749 : /* don't leak errors, this is just debug code */
3750 0 : GDKclrerr();
3751 0 : return;
3752 : case 1:
3753 : /* successfully read an entry */
3754 0 : break;
3755 0 : default:
3756 : /* error */
3757 0 : fclose(fp);
3758 0 : return;
3759 : }
3760 : #ifdef GDKLIBRARY_HASHASH
3761 0 : assert(hashash == 0);
3762 : #endif
3763 0 : assert(b.batCacheid < (bat) ATOMIC_GET(&BBPsize));
3764 0 : assert(b.hseqbase <= GDK_oid_max);
3765 0 : if (b.ttype == TYPE_void) {
3766 : /* no files needed */
3767 0 : continue;
3768 : }
3769 0 : if (b.theap->free > 0)
3770 0 : BBPcheckHeap(b.theap);
3771 0 : if (b.tvheap != NULL && b.tvheap->free > 0)
3772 0 : BBPcheckHeap(b.tvheap);
3773 : }
3774 : }
3775 :
3776 : /*
3777 : * @+ Atomic Write
3778 : * The atomic BBPsync() function first safeguards the old images of
3779 : * all files to be written in BAKDIR. It then saves all files. If that
3780 : * succeeds fully, BAKDIR is renamed to DELDIR. The rename is
3781 : * considered an atomic action. If it succeeds, the DELDIR is removed.
3782 : * If something fails, the pre-sync status can be obtained by moving
3783 : * back all backed up files; this is done by BBPrecover().
3784 : *
3785 : * The BBP.dir is also moved into the BAKDIR.
3786 : */
3787 : gdk_return
3788 13330 : BBPsync(int cnt, bat *restrict subcommit, BUN *restrict sizes, lng logno)
3789 : {
3790 13330 : gdk_return ret = GDK_SUCCEED;
3791 13330 : lng t0 = 0, t1 = 0;
3792 13330 : char bakdir[MAXPATH], deldir[MAXPATH];
3793 13330 : const bool lock = locked_by == 0 || locked_by != MT_getpid();
3794 13330 : char buf[3000];
3795 13330 : int n = subcommit ? 0 : -1;
3796 13330 : FILE *obbpf, *nbbpf;
3797 13330 : int nbats = 0;
3798 :
3799 13330 : TRC_INFO(TM, "Committing %d bats\n", cnt - 1);
3800 :
3801 26668 : if (GDKfilepath(bakdir, sizeof(bakdir), 0, NULL, subcommit ? SUBDIR : BAKDIR, NULL) != GDK_SUCCEED ||
3802 13330 : GDKfilepath(deldir, sizeof(deldir), 0, NULL, DELDIR, NULL) != GDK_SUCCEED)
3803 0 : return GDK_FAIL;
3804 :
3805 13330 : TRC_DEBUG_IF(PERF) t0 = t1 = GDKusec();
3806 :
3807 13330 : if ((ATOMIC_GET(&GDKdebug) & TAILCHKMASK) && !GDKinmemory(0))
3808 0 : BBPcheckBBPdir();
3809 :
3810 13330 : ret = BBPprepare(subcommit != NULL);
3811 :
3812 13330 : if (ret == GDK_SUCCEED) {
3813 13330 : ret = BBPdir_first(subcommit != NULL, logno, &obbpf, &nbbpf);
3814 : }
3815 :
3816 2097561 : for (int idx = 1; ret == GDK_SUCCEED && idx < cnt; idx++) {
3817 2084231 : bat i = subcommit ? subcommit[idx] : idx;
3818 2084231 : BUN size = sizes ? sizes[idx] : BUN_NONE;
3819 2084231 : BATiter bi, *bip;
3820 :
3821 2084231 : const bat bid = i;
3822 2084231 : TRC_DEBUG(TM, "Commit bat %d\n", bid);
3823 2084231 : if (lock)
3824 2073172 : MT_lock_set(&GDKswapLock(bid));
3825 : /* set flag that we're syncing, i.e. that we'll
3826 : * be between moving heap to backup dir and
3827 : * saving the new version, in other words, the
3828 : * heap may not exist in the usual location */
3829 2084231 : BBP_status_on(bid, BBPSYNCING);
3830 : /* wait until unloading is finished before
3831 : * attempting to make a backup */
3832 2084231 : while (BBP_status(bid) & BBPUNLOADING) {
3833 0 : if (lock)
3834 0 : MT_lock_unset(&GDKswapLock(bid));
3835 0 : BBPspin(bid, __func__, BBPUNLOADING);
3836 0 : if (lock)
3837 2084231 : MT_lock_set(&GDKswapLock(bid));
3838 : }
3839 2084231 : BAT *b = BBP_desc(bid);
3840 2084231 : if (subcommit && b->ttype != TYPE_void) {
3841 : /* move any tail/theap files we find for this bat that
3842 : * are in the BACKUP directory to the SUBCOMMIT
3843 : * directory */
3844 2073172 : assert(b->ttype > 0); /* no unknown types allowed */
3845 2073172 : char fname[16]; /* plenty big enough */
3846 2073172 : if (snprintf(fname, sizeof(fname), "%o", (unsigned) bid) < 16) {
3847 : /* the snprintf never fails, any of the
3848 : * below may fail */
3849 2073172 : uint8_t stpe = ATOMstorage(b->ttype);
3850 3715836 : if ((b->ttype != TYPE_str || b->twidth >= 8) &&
3851 1642664 : GDKmove(0, BAKDIR, fname, "tail", SUBDIR, fname, "tail", false) == GDK_SUCCEED)
3852 2 : TRC_DEBUG(IO, "moved %s.tail from %s to %s\n",
3853 : fname, BAKDIR, SUBDIR);
3854 2504001 : if (stpe == TYPE_str &&
3855 430829 : GDKmove(0, BAKDIR, fname, "tail1", SUBDIR, fname, "tail1", false) == GDK_SUCCEED)
3856 0 : TRC_DEBUG(IO, "moved %s.tail1 from %s to %s\n",
3857 : fname, BAKDIR, SUBDIR);
3858 545451 : if (stpe == TYPE_str && b->twidth >= 2 &&
3859 114622 : GDKmove(0, BAKDIR, fname, "tail2", SUBDIR, fname, "tail2", false) == GDK_SUCCEED)
3860 0 : TRC_DEBUG(IO, "moved %s.tail2 from %s to %s\n",
3861 : fname, BAKDIR, SUBDIR);
3862 : #if SIZEOF_VAR_T == 8
3863 2091659 : if (stpe == TYPE_str && b->twidth >= 4 &&
3864 18487 : GDKmove(0, BAKDIR, fname, "tail4", SUBDIR, fname, "tail4", false) == GDK_SUCCEED)
3865 0 : TRC_DEBUG(IO, "moved %s.tail4 from %s to %s\n",
3866 : fname, BAKDIR, SUBDIR);
3867 : #endif
3868 2505102 : if (ATOMvarsized(b->ttype) &&
3869 431930 : GDKmove(0, BAKDIR, fname, "theap", SUBDIR, fname, "theap", false) == GDK_SUCCEED)
3870 2073172 : TRC_DEBUG(IO, "moved %s.theap from %s to %s\n",
3871 : fname, BAKDIR, SUBDIR);
3872 : }
3873 : }
3874 2084231 : b = dirty_bat(&i, subcommit != NULL);
3875 2084231 : if (i <= 0)
3876 : ret = GDK_FAIL;
3877 2084231 : else if (BBP_status(bid) & BBPEXISTING &&
3878 1741311 : b != NULL &&
3879 1741311 : b->batInserted > 0)
3880 1051745 : ret = BBPbackup(b, subcommit != NULL);
3881 :
3882 2084231 : if (lock)
3883 2073172 : MT_lock_unset(&GDKswapLock(bid));
3884 :
3885 2084231 : if (ret != GDK_SUCCEED)
3886 : break;
3887 :
3888 2084231 : if (BBP_status(i) & BBPPERSISTENT) {
3889 1888915 : MT_lock_set(&BBP_desc(i)->theaplock);
3890 1888915 : bi = bat_iterator_nolock(BBP_desc(i));
3891 1888915 : bat_iterator_incref(&bi);
3892 1888915 : assert(sizes == NULL || size <= bi.count);
3893 1885269 : assert(sizes == NULL || bi.width == 0 || (bi.type == TYPE_msk ? ((size + 31) / 32) * 4 : size << bi.shift) <= bi.hfree);
3894 1888915 : if (size > bi.count) /* includes sizes==NULL */
3895 : size = bi.count;
3896 1888915 : bi.b->batInserted = size;
3897 1888915 : if (bi.b->ttype >= 0 && ATOMvarsized(bi.b->ttype)) {
3898 : /* see epilogue() for other part of this */
3899 : /* remember the tail we're saving */
3900 428349 : if (BATsetprop_nolock(bi.b, (enum prop_t) 20, TYPE_ptr, &bi.h) == NULL) {
3901 0 : GDKerror("setprop failed\n");
3902 0 : ret = GDK_FAIL;
3903 : } else {
3904 428349 : if (bi.b->oldtail == NULL)
3905 426235 : bi.b->oldtail = (Heap *) 1;
3906 428349 : HEAPincref(bi.h);
3907 : }
3908 : }
3909 1888915 : MT_lock_unset(&bi.b->theaplock);
3910 1888915 : if (ret == GDK_SUCCEED && b && size != 0) {
3911 : /* wait for BBPSAVING so that we
3912 : * can set it, wait for
3913 : * BBPUNLOADING before
3914 : * attempting to save */
3915 1162999 : for (;;) {
3916 1162999 : if (lock)
3917 1162999 : MT_lock_set(&GDKswapLock(i));
3918 1162999 : if (!(BBP_status(i) & (BBPSAVING|BBPUNLOADING)))
3919 : break;
3920 0 : if (lock)
3921 0 : MT_lock_unset(&GDKswapLock(i));
3922 0 : BBPspin(i, __func__, BBPSAVING|BBPUNLOADING);
3923 : }
3924 1162999 : BBP_status_on(i, BBPSAVING);
3925 1162999 : if (lock)
3926 1162999 : MT_lock_unset(&GDKswapLock(i));
3927 1162999 : ret = BATsave_iter(b, &bi, size);
3928 1162999 : BBP_status_off(i, BBPSAVING);
3929 : }
3930 : bip = &bi;
3931 : } else {
3932 : bip = NULL;
3933 : }
3934 2084231 : if (ret == GDK_SUCCEED) {
3935 2084231 : n = BBPdir_step(i, size, n, buf, sizeof(buf), &obbpf, nbbpf, bip, &nbats);
3936 2084231 : if (n < -1)
3937 0 : ret = GDK_FAIL;
3938 : }
3939 2084231 : if (bip)
3940 1888915 : bat_iterator_end(bip);
3941 : /* we once again have a saved heap */
3942 : }
3943 :
3944 13330 : TRC_DEBUG(PERF, "write time "LLFMT" usec\n", (t0 = GDKusec()) - t1);
3945 :
3946 13330 : if (ret == GDK_SUCCEED) {
3947 13330 : ret = BBPdir_last(n, buf, sizeof(buf), obbpf, nbbpf);
3948 : }
3949 :
3950 13330 : TRC_DEBUG(PERF, "dir time "LLFMT" usec, %d bats\n", (t1 = GDKusec()) - t0, (bat) ATOMIC_GET(&BBPsize));
3951 :
3952 13330 : if (ret == GDK_SUCCEED) {
3953 : /* atomic switchover */
3954 : /* this is the big one: this call determines
3955 : * whether the operation of this function
3956 : * succeeded, so no changing of ret after this
3957 : * call anymore */
3958 :
3959 13330 : if (MT_rename(bakdir, deldir) < 0 &&
3960 : /* maybe there was an old deldir, so remove and try again */
3961 0 : (GDKremovedir(0, DELDIR) != GDK_SUCCEED ||
3962 0 : MT_rename(bakdir, deldir) < 0))
3963 0 : ret = GDK_FAIL;
3964 0 : if (ret != GDK_SUCCEED)
3965 0 : GDKsyserror("rename(%s,%s) failed\n", bakdir, deldir);
3966 13330 : TRC_DEBUG(IO, "rename %s %s = %d\n", bakdir, deldir, (int) ret);
3967 13330 : TRC_INFO(TM, "%d bats written to BBP.dir\n", nbats);
3968 : }
3969 :
3970 : /* AFTERMATH */
3971 13330 : if (ret == GDK_SUCCEED) {
3972 13330 : ATOMIC_SET(&BBPlogno, logno); /* the new value */
3973 13330 : backup_files = subcommit ? (backup_files - backup_subdir) : 0;
3974 13330 : backup_dir = backup_subdir = 0;
3975 13330 : if (GDKremovedir(0, DELDIR) != GDK_SUCCEED)
3976 0 : fprintf(stderr, "#BBPsync: cannot remove directory %s\n", DELDIR);
3977 13330 : (void) BBPprepare(false); /* (try to) remove DELDIR and set up new BAKDIR */
3978 13330 : if (backup_files > 1) {
3979 13322 : TRC_DEBUG(PERF, "backup_files %d > 1\n", backup_files);
3980 13322 : backup_files = 1;
3981 : }
3982 : }
3983 13330 : TRC_DEBUG(PERF, "%s (ready time "LLFMT" usec)\n",
3984 : ret == GDK_SUCCEED ? "" : " failed",
3985 : (t0 = GDKusec()) - t1);
3986 :
3987 13330 : if (ret != GDK_SUCCEED) {
3988 : /* clean up extra refs we created */
3989 0 : for (int idx = 1; idx < cnt; idx++) {
3990 0 : bat i = subcommit ? subcommit[idx] : idx;
3991 0 : BAT *b = BBP_desc(i);
3992 0 : if (ATOMvarsized(b->ttype)) {
3993 0 : MT_lock_set(&b->theaplock);
3994 0 : ValPtr p = BATgetprop_nolock(b, (enum prop_t) 20);
3995 0 : if (p != NULL) {
3996 0 : HEAPdecref(p->val.pval, false);
3997 0 : BATrmprop_nolock(b, (enum prop_t) 20);
3998 : }
3999 0 : MT_lock_unset(&b->theaplock);
4000 : }
4001 : }
4002 : }
4003 :
4004 : /* turn off the BBPSYNCING bits for all bats, even when things
4005 : * didn't go according to plan (i.e., don't check for ret ==
4006 : * GDK_SUCCEED) */
4007 2097561 : for (int idx = 1; idx < cnt; idx++) {
4008 2084231 : bat i = subcommit ? subcommit[idx] : idx;
4009 2084231 : BBP_status_off(i, BBPSYNCING);
4010 : }
4011 :
4012 : return ret;
4013 : }
4014 :
4015 : /*
4016 : * Recovery just moves all files back to their original location. this
4017 : * is an incremental process: if something fails, just stop with still
4018 : * files left for moving in BACKUP/. The recovery process can resume
4019 : * later with the left over files.
4020 : */
4021 : static gdk_return
4022 0 : force_move(int farmid, const char *srcdir, const char *dstdir, const char *name)
4023 : {
4024 0 : const char *p;
4025 0 : char dstpath[MAXPATH], path2[MAXPATH];
4026 0 : gdk_return ret = GDK_SUCCEED;
4027 :
4028 0 : if ((p = strrchr(name, '.')) != NULL && strcmp(p, ".kill") == 0) {
4029 : /* Found a X.new.kill file, ie remove the X.new file */
4030 0 : ptrdiff_t len = p - name;
4031 0 : long_str srcpath;
4032 :
4033 0 : strncpy(srcpath, name, len);
4034 0 : srcpath[len] = '\0';
4035 0 : if (GDKfilepath(dstpath, sizeof(dstpath), farmid, dstdir, srcpath, NULL) != GDK_SUCCEED) {
4036 : return GDK_FAIL;
4037 : }
4038 :
4039 : /* step 1: remove the X.new file that is going to be
4040 : * overridden by X */
4041 0 : if (MT_remove(dstpath) != 0 && errno != ENOENT) {
4042 : /* if it exists and cannot be removed, all
4043 : * this is going to fail */
4044 0 : GDKsyserror("force_move: remove(%s)\n", dstpath);
4045 0 : return GDK_FAIL;
4046 : }
4047 :
4048 : /* step 2: now remove the .kill file. This one is
4049 : * crucial, otherwise we'll never finish recovering */
4050 0 : if (GDKfilepath(path2, sizeof(path2), farmid, srcdir, name, NULL) != GDK_SUCCEED) {
4051 : return GDK_FAIL;
4052 : }
4053 0 : if (MT_remove(path2) != 0) {
4054 0 : ret = GDK_FAIL;
4055 0 : GDKsyserror("force_move: remove(%s)\n", path2);
4056 : }
4057 0 : return ret;
4058 : }
4059 : /* try to rename it */
4060 0 : ret = GDKmove(farmid, srcdir, name, NULL, dstdir, name, NULL, false);
4061 :
4062 0 : if (ret != GDK_SUCCEED) {
4063 0 : GDKclrerr();
4064 : /* two legal possible causes: file exists or dir
4065 : * doesn't exist */
4066 0 : if (GDKfilepath(dstpath, sizeof(dstpath), farmid, dstdir, name, NULL) != GDK_SUCCEED ||
4067 0 : GDKfilepath(path2, sizeof(path2), farmid, srcdir, name, NULL) != GDK_SUCCEED) {
4068 0 : return GDK_FAIL;
4069 : }
4070 0 : if (MT_remove(dstpath) != 0) /* clear destination */
4071 0 : ret = GDK_FAIL;
4072 0 : TRC_DEBUG(IO, "remove %s = %d\n", dstpath, (int) ret);
4073 :
4074 0 : (void) GDKcreatedir(dstdir); /* if fails, move will fail */
4075 0 : ret = GDKmove(farmid, srcdir, name, NULL, dstdir, name, NULL, true);
4076 0 : TRC_DEBUG(IO, "link %s %s = %d\n", path2, dstpath, (int) ret);
4077 : }
4078 : return ret;
4079 : }
4080 :
4081 : gdk_return
4082 364 : BBPrecover(int farmid)
4083 : {
4084 364 : char bakdirpath[MAXPATH];
4085 364 : char leftdirpath[MAXPATH];
4086 364 : DIR *dirp;
4087 364 : struct dirent *dent;
4088 364 : long_str path, dstpath;
4089 364 : bat i;
4090 364 : size_t j = strlen(BATDIR);
4091 364 : gdk_return ret = GDK_SUCCEED;
4092 364 : bool dirseen = false;
4093 364 : str dstdir;
4094 :
4095 728 : if (GDKfilepath(bakdirpath, sizeof(bakdirpath), farmid, NULL, BAKDIR, NULL) != GDK_SUCCEED ||
4096 364 : GDKfilepath(leftdirpath, sizeof(leftdirpath), farmid, NULL, LEFTDIR, NULL) != GDK_SUCCEED) {
4097 0 : return GDK_FAIL;
4098 : }
4099 364 : dirp = opendir(bakdirpath);
4100 364 : if (dirp == NULL) {
4101 237 : if (errno != ENOENT)
4102 0 : GDKsyserror("cannot open directory %s\n", bakdirpath);
4103 237 : return GDK_SUCCEED; /* nothing to do */
4104 : }
4105 127 : memcpy(dstpath, BATDIR, j);
4106 127 : dstpath[j] = DIR_SEP;
4107 127 : dstpath[++j] = 0;
4108 127 : dstdir = dstpath + j;
4109 127 : TRC_DEBUG(IO, "start\n");
4110 :
4111 127 : if (MT_mkdir(leftdirpath) < 0 && errno != EEXIST) {
4112 0 : GDKsyserror("cannot create directory %s\n", leftdirpath);
4113 0 : closedir(dirp);
4114 0 : return GDK_FAIL;
4115 : }
4116 :
4117 : /* move back all files */
4118 : char fn[MAXPATH];
4119 381 : while ((dent = readdir(dirp)) != NULL) {
4120 254 : const char *q = strchr(dent->d_name, '.');
4121 :
4122 254 : if (q == dent->d_name) {
4123 254 : if (strcmp(dent->d_name, ".") == 0 ||
4124 127 : strcmp(dent->d_name, "..") == 0)
4125 254 : continue;
4126 0 : if (GDKfilepath(fn, sizeof(fn), farmid, BAKDIR, dent->d_name, NULL) == GDK_SUCCEED) {
4127 0 : int uret = MT_remove(fn);
4128 0 : TRC_DEBUG(IO, "remove %s = %d\n",
4129 : fn, uret);
4130 : }
4131 0 : continue;
4132 0 : } else if (strcmp(dent->d_name, "BBP.dir") == 0) {
4133 0 : dirseen = true;
4134 0 : continue;
4135 : }
4136 0 : if (q == NULL)
4137 0 : q = dent->d_name + strlen(dent->d_name);
4138 0 : if ((j = q - dent->d_name) + 1 > sizeof(path)) {
4139 : /* name too long: ignore */
4140 0 : continue;
4141 : }
4142 0 : strncpy(path, dent->d_name, j);
4143 0 : path[j] = 0;
4144 0 : if (GDKisdigit(*path)) {
4145 0 : i = strtol(path, NULL, 8);
4146 : } else {
4147 0 : i = BBP_find(path, false);
4148 0 : if (i < 0)
4149 0 : i = -i;
4150 : }
4151 0 : if (i == 0 || i >= (bat) ATOMIC_GET(&BBPsize) || !BBPvalid(i)) {
4152 0 : force_move(farmid, BAKDIR, LEFTDIR, dent->d_name);
4153 : } else {
4154 0 : BBPgetsubdir(dstdir, i);
4155 0 : if (force_move(farmid, BAKDIR, dstpath, dent->d_name) != GDK_SUCCEED) {
4156 : ret = GDK_FAIL;
4157 : break;
4158 : }
4159 : /* don't trust index files after recovery */
4160 0 : GDKunlink(farmid, dstpath, path, "thashl");
4161 0 : GDKunlink(farmid, dstpath, path, "thashb");
4162 0 : GDKunlink(farmid, dstpath, path, "torderidx");
4163 0 : GDKunlink(farmid, dstpath, path, "tstrimps");
4164 : }
4165 : }
4166 127 : closedir(dirp);
4167 127 : if (dirseen && ret == GDK_SUCCEED) { /* we have a saved BBP.dir; it should be moved back!! */
4168 0 : struct stat st;
4169 :
4170 0 : if (GDKfilepath(fn, sizeof(fn), farmid, BATDIR, "BBP", "dir") != GDK_SUCCEED) {
4171 : ret = GDK_FAIL;
4172 : } else {
4173 0 : ret = recover_dir(farmid, MT_stat(fn, &st) == 0);
4174 : }
4175 : }
4176 :
4177 127 : if (ret == GDK_SUCCEED) {
4178 127 : if (MT_rmdir(bakdirpath) < 0) {
4179 0 : GDKsyserror("cannot remove directory %s\n", bakdirpath);
4180 0 : ret = GDK_FAIL;
4181 : }
4182 127 : TRC_DEBUG(IO, "rmdir %s = %d\n", bakdirpath, (int) ret);
4183 : }
4184 127 : if (ret != GDK_SUCCEED)
4185 0 : GDKerror("recovery failed.\n");
4186 :
4187 127 : TRC_DEBUG(IO, "end\n");
4188 : return ret;
4189 : }
4190 :
4191 : /*
4192 : * SUBDIR recovery is quite mindlessly moving all files back to the
4193 : * parent (BAKDIR). We do recognize moving back BBP.dir and set
4194 : * backed_up_subdir accordingly.
4195 : */
4196 : gdk_return
4197 13678 : BBPrecover_subdir(void)
4198 : {
4199 13678 : char subdirpath[MAXPATH];
4200 13678 : DIR *dirp;
4201 13678 : struct dirent *dent;
4202 13678 : gdk_return ret = GDK_SUCCEED;
4203 :
4204 13678 : if (GDKfilepath(subdirpath, sizeof(subdirpath), 0, NULL, SUBDIR, NULL) != GDK_SUCCEED)
4205 : return GDK_FAIL;
4206 13678 : dirp = opendir(subdirpath);
4207 13678 : if (dirp == NULL && errno != ENOENT)
4208 0 : GDKsyserror("cannot open directory %s\n", subdirpath);
4209 13678 : if (dirp == NULL) {
4210 13678 : return GDK_SUCCEED; /* nothing to do */
4211 : }
4212 0 : TRC_DEBUG(IO, "start\n");
4213 :
4214 : /* move back all files */
4215 0 : while ((dent = readdir(dirp)) != NULL) {
4216 0 : if (dent->d_name[0] == '.')
4217 0 : continue;
4218 0 : ret = GDKmove(0, SUBDIR, dent->d_name, NULL, BAKDIR, dent->d_name, NULL, true);
4219 0 : if (ret != GDK_SUCCEED)
4220 : break;
4221 0 : if (strcmp(dent->d_name, "BBP.dir") == 0)
4222 0 : backup_dir = 1;
4223 : }
4224 0 : closedir(dirp);
4225 :
4226 : /* delete the directory */
4227 0 : if (ret == GDK_SUCCEED) {
4228 0 : ret = GDKremovedir(0, SUBDIR);
4229 0 : if (backup_dir == 2) {
4230 0 : TRC_DEBUG(IO, "%s%cBBP.dir had disappeared!\n", SUBDIR, DIR_SEP);
4231 0 : backup_dir = 0;
4232 : }
4233 : }
4234 0 : TRC_DEBUG(IO, "end = %d\n", (int) ret);
4235 :
4236 0 : if (ret != GDK_SUCCEED)
4237 0 : GDKerror("recovery failed.\n");
4238 : return ret;
4239 : }
4240 :
4241 : /*
4242 : * @- The diskscan
4243 : * The BBPdiskscan routine walks through the BAT dir, cleans up
4244 : * leftovers, and measures disk occupancy. Leftovers are files that
4245 : * cannot belong to a BAT. in order to establish this for [ht]heap
4246 : * files, the BAT descriptor is loaded in order to determine whether
4247 : * these files are still required.
4248 : *
4249 : * The routine gathers all bat sizes in a bat that contains bat-ids
4250 : * and bytesizes. The return value is the number of bytes of space
4251 : * freed.
4252 : */
4253 : static bool
4254 30161 : persistent_bat(bat bid)
4255 : {
4256 30161 : if (bid >= 0 && bid < (bat) ATOMIC_GET(&BBPsize) && BBPvalid(bid)) {
4257 30161 : BAT *b = BBP_desc(bid);
4258 30161 : if ((BBP_status(bid) & BBPLOADED) == 0 || b->batCopiedtodisk) {
4259 : return true;
4260 : }
4261 : }
4262 : return false;
4263 : }
4264 :
4265 : static BAT *
4266 30161 : getdesc(bat bid)
4267 : {
4268 30161 : BAT *b = NULL;
4269 :
4270 30161 : if (is_bat_nil(bid))
4271 : return NULL;
4272 30161 : assert(bid > 0);
4273 30161 : if (bid < (bat) ATOMIC_GET(&BBPsize) && BBP_logical(bid))
4274 30161 : b = BBP_desc(bid);
4275 30161 : if (b == NULL)
4276 0 : BBPclear(bid);
4277 : return b;
4278 : }
4279 :
4280 : static bool
4281 1966 : BBPdiskscan(const char *parent, size_t baseoff)
4282 : {
4283 1966 : DIR *dirp = opendir(parent);
4284 1966 : struct dirent *dent;
4285 1966 : char fullname[FILENAME_MAX];
4286 1966 : str dst;
4287 1966 : size_t dstlen;
4288 1966 : const char *src = parent;
4289 :
4290 1966 : if (dirp == NULL) {
4291 191 : if (errno != ENOENT)
4292 0 : GDKsyserror("cannot open directory %s\n", parent);
4293 191 : return true; /* nothing to do */
4294 : }
4295 :
4296 1775 : dst = stpcpy(fullname, src);
4297 1775 : if (dst > fullname && dst[-1] != DIR_SEP)
4298 1775 : *dst++ = DIR_SEP;
4299 1775 : dstlen = sizeof(fullname) - (dst - fullname);
4300 :
4301 39036 : while ((dent = readdir(dirp)) != NULL) {
4302 35486 : const char *p;
4303 35486 : bat bid;
4304 35486 : bool ok, delete;
4305 :
4306 35486 : if (dent->d_name[0] == '.')
4307 3550 : continue; /* ignore .dot files and directories (. ..) */
4308 :
4309 : #ifdef GDKLIBRARY_JSON
4310 31936 : if (strcmp(dent->d_name, "jsonupgradeneeded") == 0) {
4311 0 : continue; /* ignore json upgrade signal file */
4312 : }
4313 : #endif
4314 :
4315 31936 : if (strncmp(dent->d_name, "BBP.", 4) == 0 &&
4316 356 : (strcmp(parent + baseoff, BATDIR) == 0 ||
4317 356 : strncmp(parent + baseoff, BAKDIR, strlen(BAKDIR)) == 0 ||
4318 0 : strncmp(parent + baseoff, SUBDIR, strlen(SUBDIR)) == 0))
4319 356 : continue;
4320 :
4321 31580 : p = strchr(dent->d_name, '.');
4322 :
4323 31580 : if (strlen(dent->d_name) >= dstlen) {
4324 : /* found a file with too long a name
4325 : (i.e. unknown); stop pruning in this
4326 : subdir */
4327 0 : fprintf(stderr, "unexpected file %s, leaving %s.\n", dent->d_name, parent);
4328 0 : break;
4329 : }
4330 31580 : strncpy(dst, dent->d_name, dstlen);
4331 31580 : fullname[sizeof(fullname) - 1] = 0;
4332 :
4333 31580 : if (p == NULL && !BBPdiskscan(fullname, baseoff)) {
4334 : /* it was a directory */
4335 1419 : continue;
4336 : }
4337 :
4338 30161 : if (p && strcmp(p + 1, "tmp") == 0) {
4339 : delete = true;
4340 : ok = true;
4341 30161 : bid = 0;
4342 : } else {
4343 30161 : bid = strtol(dent->d_name, NULL, 8);
4344 30161 : ok = p && bid;
4345 30161 : delete = false;
4346 :
4347 30161 : if (!ok || !persistent_bat(bid)) {
4348 : delete = true;
4349 30161 : } else if (strncmp(p + 1, "tail", 4) == 0) {
4350 22447 : BAT *b = getdesc(bid);
4351 22447 : delete = (b == NULL || !b->ttype || !b->batCopiedtodisk || b->batCount == 0);
4352 22447 : assert(b == NULL || b->batCount > 0 || b->theap->free == 0);
4353 22447 : if (!delete) {
4354 22445 : if (b->ttype == TYPE_str) {
4355 6249 : switch (b->twidth) {
4356 3776 : case 1:
4357 3776 : delete = strcmp(p + 1, "tail1") != 0;
4358 3776 : break;
4359 2039 : case 2:
4360 2039 : delete = strcmp(p + 1, "tail2") != 0;
4361 2039 : break;
4362 : #if SIZEOF_VAR_T == 8
4363 434 : case 4:
4364 434 : delete = strcmp(p + 1, "tail4") != 0;
4365 434 : break;
4366 : #endif
4367 0 : default:
4368 0 : delete = strcmp(p + 1, "tail") != 0;
4369 0 : break;
4370 : }
4371 : } else {
4372 16196 : delete = strcmp(p + 1, "tail") != 0;
4373 : }
4374 : }
4375 7714 : } else if (strncmp(p + 1, "theap", 5) == 0) {
4376 6517 : BAT *b = getdesc(bid);
4377 6517 : delete = (b == NULL || !b->tvheap || !b->batCopiedtodisk || b->tvheap->free == 0);
4378 1197 : } else if (strncmp(p + 1, "thashl", 6) == 0 ||
4379 599 : strncmp(p + 1, "thashb", 6) == 0) {
4380 1196 : BAT *b = getdesc(bid);
4381 1196 : delete = b == NULL;
4382 1196 : if (!delete)
4383 1196 : b->thash = (Hash *) 1;
4384 1 : } else if (strncmp(p + 1, "thash", 5) == 0) {
4385 : /* older versions used .thash which we
4386 : * can simply ignore */
4387 : delete = true;
4388 1 : } else if (strncmp(p + 1, "thsh", 4) == 0) {
4389 : /* temporary hash files which we can
4390 : * simply ignore */
4391 : delete = true;
4392 1 : } else if (strncmp(p + 1, "timprints", 9) == 0) {
4393 : /* imprints have been removed */
4394 : delete = true;
4395 1 : } else if (strncmp(p + 1, "torderidx", 9) == 0) {
4396 0 : BAT *b = getdesc(bid);
4397 0 : delete = b == NULL;
4398 0 : if (!delete)
4399 0 : b->torderidx = (Heap *) 1;
4400 1 : } else if (strncmp(p + 1, "tstrimps", 8) == 0) {
4401 1 : BAT *b = getdesc(bid);
4402 1 : delete = b == NULL;
4403 1 : if (!delete)
4404 1 : b->tstrimps = (Strimps *)1;
4405 0 : } else if (strncmp(p + 1, "new", 3) != 0) {
4406 30161 : ok = false;
4407 : }
4408 : }
4409 30161 : if (!ok) {
4410 : /* found an unknown file; stop pruning in this
4411 : * subdir */
4412 0 : fprintf(stderr, "unexpected file %s, leaving %s.\n", dent->d_name, parent);
4413 0 : break;
4414 : }
4415 30161 : if (delete) {
4416 2 : if (MT_remove(fullname) != 0 && errno != ENOENT) {
4417 0 : GDKsyserror("remove(%s)", fullname);
4418 0 : continue;
4419 : }
4420 37263 : TRC_DEBUG(IO, "remove(%s) = 0\n", fullname);
4421 : }
4422 : }
4423 1775 : closedir(dirp);
4424 1775 : return false;
4425 : }
4426 :
4427 : void
4428 355 : gdk_bbp_reset(void)
4429 : {
4430 355 : int i;
4431 :
4432 355 : BBP_free = 0;
4433 355 : BBP_nfree = 0;
4434 355 : while (BBPlimit > BBPINIT) {
4435 0 : BBPlimit -= BBPINIT;
4436 0 : assert(BBPlimit >= 0);
4437 0 : GDKfree(BBP[BBPlimit >> BBPINITLOG]);
4438 0 : BBP[BBPlimit >> BBPINITLOG] = NULL;
4439 : }
4440 355 : ATOMIC_SET(&BBPsize, 0);
4441 355 : memset(BBP0, 0, sizeof(BBP0));
4442 11715 : for (i = 0; i < MAXFARMS; i++)
4443 11360 : GDKfree((void *) BBPfarms[i].dirname); /* loose "const" */
4444 355 : memset(BBPfarms, 0, sizeof(BBPfarms));
4445 355 : memset(BBP_hash, 0, sizeof(BBP_hash));
4446 :
4447 355 : locked_by = 0;
4448 355 : BBPunloadCnt = 0;
4449 355 : backup_files = 0;
4450 355 : backup_dir = 0;
4451 355 : backup_subdir = 0;
4452 355 : }
4453 :
4454 : static MT_Lock GDKCallbackListLock = MT_LOCK_INITIALIZER(GDKCallbackListLock);
4455 :
4456 : typedef struct gdk_callback {
4457 : const char *name;
4458 : int argc;
4459 : int interval; // units sec
4460 : lng last_called; // timestamp GDKusec
4461 : gdk_return (*func)(int argc, void *argv[]);
4462 : struct gdk_callback *next;
4463 : void *argv[];
4464 : } gdk_callback;
4465 :
4466 : static struct {
4467 : int cnt;
4468 : gdk_callback *head;
4469 : } callback_list = {
4470 : .cnt = 0,
4471 : .head = NULL,
4472 : };
4473 :
4474 : /*
4475 : * @- Add a callback
4476 : * Adds new callback to the callback list.
4477 : */
4478 : gdk_return
4479 0 : gdk_add_callback(const char *name, gdk_callback_func *f, int argc, void *argv[], int
4480 : interval)
4481 : {
4482 :
4483 0 : gdk_callback *callback = NULL;
4484 :
4485 0 : if (!(callback = GDKmalloc(sizeof(gdk_callback) + sizeof(void *) * argc))) {
4486 0 : TRC_CRITICAL(GDK, "Failed to allocate memory!");
4487 0 : return GDK_FAIL;
4488 : }
4489 :
4490 0 : *callback = (gdk_callback) {
4491 : .name = name,
4492 : .argc = argc,
4493 : .interval = interval,
4494 : .func = f,
4495 : };
4496 :
4497 0 : for (int i=0; i < argc; i++) {
4498 0 : callback->argv[i] = argv[i];
4499 : }
4500 :
4501 0 : MT_lock_set(&GDKCallbackListLock);
4502 0 : gdk_callback *p = callback_list.head;
4503 0 : if (p) {
4504 : int cnt = 1;
4505 0 : do {
4506 : /* check if already added */
4507 0 : if (strcmp(callback->name, p->name) == 0) {
4508 0 : MT_lock_unset(&GDKCallbackListLock);
4509 0 : GDKfree(callback);
4510 0 : return GDK_FAIL;
4511 : }
4512 0 : if (p->next == NULL) {
4513 0 : p->next = callback;
4514 0 : p = callback->next;
4515 : } else {
4516 : p = p->next;
4517 : }
4518 0 : cnt += 1;
4519 0 : } while(p);
4520 0 : callback_list.cnt = cnt;
4521 : } else {
4522 0 : callback_list.cnt = 1;
4523 0 : callback_list.head = callback;
4524 : }
4525 0 : MT_lock_unset(&GDKCallbackListLock);
4526 0 : return GDK_SUCCEED;
4527 : }
4528 :
4529 : /*
4530 : * @- Remove a callback
4531 : * Removes a callback from the callback list with a given name as an argument.
4532 : */
4533 : gdk_return
4534 0 : gdk_remove_callback(const char *cb_name, gdk_callback_func *argsfree)
4535 : {
4536 0 : gdk_callback *prev = NULL;
4537 0 : gdk_return res = GDK_FAIL;
4538 :
4539 0 : MT_lock_set(&GDKCallbackListLock);
4540 0 : gdk_callback *curr = callback_list.head;
4541 0 : while(curr) {
4542 0 : if (strcmp(cb_name, curr->name) == 0) {
4543 0 : if (curr == callback_list.head && prev == NULL) {
4544 0 : callback_list.head = curr->next;
4545 : } else {
4546 0 : prev->next = curr->next;
4547 : }
4548 0 : if (argsfree)
4549 0 : argsfree(curr->argc, curr->argv);
4550 0 : GDKfree(curr);
4551 0 : curr = NULL;
4552 0 : callback_list.cnt -=1;
4553 0 : res = GDK_SUCCEED;
4554 : } else {
4555 0 : prev = curr;
4556 0 : curr = curr->next;
4557 : }
4558 : }
4559 0 : MT_lock_unset(&GDKCallbackListLock);
4560 0 : return res;
4561 : }
4562 :
4563 : static gdk_return
4564 0 : do_callback(gdk_callback *cb)
4565 : {
4566 0 : cb->last_called = GDKusec();
4567 0 : return cb->func(cb->argc, cb->argv);
4568 : }
4569 :
4570 : static bool
4571 0 : should_call(gdk_callback *cb)
4572 : {
4573 0 : if (cb->last_called && cb->interval) {
4574 0 : return (cb->last_called + cb->interval * 1000 * 1000) <
4575 0 : GDKusec();
4576 : }
4577 : return true;
4578 : }
4579 :
4580 : static void
4581 116 : BBPcallbacks(void)
4582 : {
4583 116 : MT_lock_set(&GDKCallbackListLock);
4584 116 : gdk_callback *next = callback_list.head;
4585 :
4586 116 : while (next) {
4587 0 : if(should_call(next))
4588 0 : do_callback(next);
4589 0 : next = next->next;
4590 : }
4591 116 : MT_lock_unset(&GDKCallbackListLock);
4592 116 : }
4593 :
4594 : /* GDKtmLock protects all accesses and changes to BAKDIR and SUBDIR.
4595 : * MUST use BBPtmlock()/BBPtmunlock() to set/unset the lock.
4596 : *
4597 : * This is at the end of the file on purpose: we don't want people to
4598 : * accidentally use GDKtmLock directly. */
4599 : static MT_Lock GDKtmLock = MT_LOCK_INITIALIZER(GDKtmLock);
4600 : static int lockfd = -1;
4601 : static char lockfile[MAXPATH];
4602 :
4603 : static void
4604 125395 : BBPtmlockFinish(void)
4605 : {
4606 250790 : if (!GDKinmemory(0) &&
4607 : /* also use an external lock file to synchronize with
4608 : * external programs */
4609 125395 : GDKfilepath(lockfile, sizeof(lockfile), 0, NULL, ".tm_lock", NULL) == GDK_SUCCEED) {
4610 125395 : lockfd = MT_lockf(lockfile, F_LOCK);
4611 : }
4612 125395 : }
4613 :
4614 : void
4615 125277 : BBPtmlock(void)
4616 : {
4617 125277 : MT_lock_set(&GDKtmLock);
4618 125277 : BBPtmlockFinish();
4619 125277 : }
4620 :
4621 : static bool
4622 118 : BBPtrytmlock(int ms)
4623 : {
4624 118 : if (!MT_lock_trytime(&GDKtmLock, ms))
4625 0 : return false;
4626 118 : BBPtmlockFinish();
4627 118 : return true;
4628 : }
4629 :
4630 : void
4631 125395 : BBPtmunlock(void)
4632 : {
4633 125395 : if (lockfd >= 0) {
4634 125395 : assert(!GDKinmemory(0));
4635 125395 : MT_lockf(lockfile, F_ULOCK);
4636 125395 : close(lockfd);
4637 125395 : lockfd = -1;
4638 : }
4639 125395 : MT_lock_unset(&GDKtmLock);
4640 125395 : }
4641 :
4642 : void
4643 118 : BBPprintinfo(void)
4644 : {
4645 : /* 32 categories for the bats, not all are expected to be filled */
4646 118 : struct counters {
4647 : size_t sz;
4648 : size_t vmsz;
4649 : int nr;
4650 118 : } bats[2][2][2][2][2] = {0};
4651 118 : int nbats = 0;
4652 118 : int nskip = 0;
4653 :
4654 118 : if (!BBPtrytmlock(1000)) {
4655 0 : printf("BBP is currently locked, so no BAT information\n");
4656 0 : return;
4657 : }
4658 118 : bat sz = (bat) ATOMIC_GET(&BBPsize);
4659 229558 : for (bat i = 1; i < sz; i++) {
4660 229440 : if (!MT_lock_trytime(&GDKswapLock(i), 1000)) {
4661 0 : nskip++;
4662 0 : continue;
4663 : }
4664 229440 : int r;
4665 229440 : if ((r = BBP_refs(i)) > 0 || BBP_lrefs(i) > 0) {
4666 191744 : BAT *b = BBP_desc(i);
4667 191744 : if (!MT_lock_trytime(&b->theaplock, 1000)) {
4668 0 : nskip++;
4669 0 : b = NULL;
4670 : }
4671 0 : if (b != NULL) {
4672 191744 : nbats++;
4673 191744 : ATOMIC_BASE_TYPE status = BBP_status(i);
4674 191744 : struct counters *bt = &bats[r > 0][BATdirty(b)][(status & BBPPERSISTENT) != 0][(status & BBPLOADED) != 0][(status & BBPHOT) != 0];
4675 191744 : bt->nr++;
4676 191744 : if (b->theap && b->batCacheid == b->theap->parentid) {
4677 191744 : bt->sz += HEAPmemsize(b->theap);
4678 191744 : bt->vmsz += HEAPvmsize(b->theap);
4679 : }
4680 191744 : if (b->tvheap && b->batCacheid == b->tvheap->parentid) {
4681 11256 : bt->sz += HEAPmemsize(b->tvheap);
4682 11256 : bt->vmsz += HEAPvmsize(b->tvheap);
4683 : }
4684 191744 : MT_lock_unset(&b->theaplock);
4685 : }
4686 : }
4687 229440 : MT_lock_unset(&GDKswapLock(i));
4688 : }
4689 118 : uint32_t nfree = 0;
4690 118 : if (MT_lock_trytime(&GDKcacheLock, 1000)) {
4691 118 : nfree = BBP_nfree;
4692 118 : MT_lock_unset(&GDKcacheLock);
4693 : }
4694 118 : BBPtmunlock();
4695 118 : printf("BATs:\n");
4696 118 : if (bats[1][1][1][1][1].nr > 0)
4697 118 : printf("fix, dirty, persistent, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][1][1][1][1].nr, bats[1][1][1][1][1].vmsz, bats[1][1][1][1][1].sz);
4698 118 : if (bats[1][1][1][1][0].nr > 0)
4699 0 : printf("fix, dirty, persistent, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][1][1][1][0].nr, bats[1][1][1][1][0].vmsz, bats[1][1][1][1][0].sz);
4700 118 : if (bats[1][1][1][0][1].nr > 0)
4701 0 : printf("fix, dirty, persistent, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][1][1][0][1].nr, bats[1][1][1][0][1].vmsz, bats[1][1][1][0][1].sz);
4702 118 : if (bats[1][1][1][0][0].nr > 0)
4703 0 : printf("fix, dirty, persistent, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][1][1][0][0].nr, bats[1][1][1][0][0].vmsz, bats[1][1][1][0][0].sz);
4704 118 : if (bats[1][1][0][1][1].nr > 0)
4705 118 : printf("fix, dirty, transient, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][1][0][1][1].nr, bats[1][1][0][1][1].vmsz, bats[1][1][0][1][1].sz);
4706 118 : if (bats[1][1][0][1][0].nr > 0)
4707 1 : printf("fix, dirty, transient, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][1][0][1][0].nr, bats[1][1][0][1][0].vmsz, bats[1][1][0][1][0].sz);
4708 118 : if (bats[1][1][0][0][1].nr > 0)
4709 0 : printf("fix, dirty, transient, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][1][0][0][1].nr, bats[1][1][0][0][1].vmsz, bats[1][1][0][0][1].sz);
4710 118 : if (bats[1][1][0][0][0].nr > 0)
4711 0 : printf("fix, dirty, transient, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][1][0][0][0].nr, bats[1][1][0][0][0].vmsz, bats[1][1][0][0][0].sz);
4712 118 : if (bats[1][0][1][1][1].nr > 0)
4713 109 : printf("fix, clean, persistent, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][0][1][1][1].nr, bats[1][0][1][1][1].vmsz, bats[1][0][1][1][1].sz);
4714 118 : if (bats[1][0][1][1][0].nr > 0)
4715 0 : printf("fix, clean, persistent, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][0][1][1][0].nr, bats[1][0][1][1][0].vmsz, bats[1][0][1][1][0].sz);
4716 118 : if (bats[1][0][1][0][1].nr > 0)
4717 0 : printf("fix, clean, persistent, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][0][1][0][1].nr, bats[1][0][1][0][1].vmsz, bats[1][0][1][0][1].sz);
4718 118 : if (bats[1][0][1][0][0].nr > 0)
4719 0 : printf("fix, clean, persistent, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][0][1][0][0].nr, bats[1][0][1][0][0].vmsz, bats[1][0][1][0][0].sz);
4720 118 : if (bats[1][0][0][1][1].nr > 0)
4721 0 : printf("fix, clean, transient, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][0][0][1][1].nr, bats[1][0][0][1][1].vmsz, bats[1][0][0][1][1].sz);
4722 118 : if (bats[1][0][0][1][0].nr > 0)
4723 0 : printf("fix, clean, transient, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[1][0][0][1][0].nr, bats[1][0][0][1][0].vmsz, bats[1][0][0][1][0].sz);
4724 118 : if (bats[1][0][0][0][1].nr > 0)
4725 0 : printf("fix, clean, transient, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][0][0][0][1].nr, bats[1][0][0][0][1].vmsz, bats[1][0][0][0][1].sz);
4726 118 : if (bats[1][0][0][0][0].nr > 0)
4727 0 : printf("fix, clean, transient, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[1][0][0][0][0].nr, bats[1][0][0][0][0].vmsz, bats[1][0][0][0][0].sz);
4728 118 : if (bats[0][1][1][1][1].nr > 0)
4729 114 : printf("no fix, dirty, persistent, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][1][1][1][1].nr, bats[0][1][1][1][1].vmsz, bats[0][1][1][1][1].sz);
4730 118 : if (bats[0][1][1][1][0].nr > 0)
4731 29 : printf("no fix, dirty, persistent, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][1][1][1][0].nr, bats[0][1][1][1][0].vmsz, bats[0][1][1][1][0].sz);
4732 118 : if (bats[0][1][1][0][1].nr > 0)
4733 0 : printf("no fix, dirty, persistent, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][1][1][0][1].nr, bats[0][1][1][0][1].vmsz, bats[0][1][1][0][1].sz);
4734 118 : if (bats[0][1][1][0][0].nr > 0)
4735 0 : printf("no fix, dirty, persistent, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][1][1][0][0].nr, bats[0][1][1][0][0].vmsz, bats[0][1][1][0][0].sz);
4736 118 : if (bats[0][1][0][1][1].nr > 0)
4737 98 : printf("no fix, dirty, transient, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][1][0][1][1].nr, bats[0][1][0][1][1].vmsz, bats[0][1][0][1][1].sz);
4738 118 : if (bats[0][1][0][1][0].nr > 0)
4739 15 : printf("no fix, dirty, transient, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][1][0][1][0].nr, bats[0][1][0][1][0].vmsz, bats[0][1][0][1][0].sz);
4740 118 : if (bats[0][1][0][0][1].nr > 0)
4741 0 : printf("no fix, dirty, transient, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][1][0][0][1].nr, bats[0][1][0][0][1].vmsz, bats[0][1][0][0][1].sz);
4742 118 : if (bats[0][1][0][0][0].nr > 0)
4743 17 : printf("no fix, dirty, transient, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][1][0][0][0].nr, bats[0][1][0][0][0].vmsz, bats[0][1][0][0][0].sz);
4744 118 : if (bats[0][0][1][1][1].nr > 0)
4745 116 : printf("no fix, clean, persistent, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][0][1][1][1].nr, bats[0][0][1][1][1].vmsz, bats[0][0][1][1][1].sz);
4746 118 : if (bats[0][0][1][1][0].nr > 0)
4747 21 : printf("no fix, clean, persistent, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][0][1][1][0].nr, bats[0][0][1][1][0].vmsz, bats[0][0][1][1][0].sz);
4748 118 : if (bats[0][0][1][0][1].nr > 0)
4749 0 : printf("no fix, clean, persistent, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][0][1][0][1].nr, bats[0][0][1][0][1].vmsz, bats[0][0][1][0][1].sz);
4750 118 : if (bats[0][0][1][0][0].nr > 0)
4751 18 : printf("no fix, clean, persistent, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][0][1][0][0].nr, bats[0][0][1][0][0].vmsz, bats[0][0][1][0][0].sz);
4752 118 : if (bats[0][0][0][1][1].nr > 0)
4753 4 : printf("no fix, clean, transient, loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][0][0][1][1].nr, bats[0][0][0][1][1].vmsz, bats[0][0][0][1][1].sz);
4754 118 : if (bats[0][0][0][1][0].nr > 0)
4755 0 : printf("no fix, clean, transient, not loaded, hot: %d bats, %zu virtual, %zu malloc\n", bats[0][0][0][1][0].nr, bats[0][0][0][1][0].vmsz, bats[0][0][0][1][0].sz);
4756 118 : if (bats[0][0][0][0][1].nr > 0)
4757 0 : printf("no fix, clean, transient, loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][0][0][0][1].nr, bats[0][0][0][0][1].vmsz, bats[0][0][0][0][1].sz);
4758 118 : if (bats[0][0][0][0][0].nr > 0)
4759 0 : printf("no fix, clean, transient, not loaded, cold: %d bats, %zu virtual, %zu malloc\n", bats[0][0][0][0][0].nr, bats[0][0][0][0][0].vmsz, bats[0][0][0][0][0].sz);
4760 :
4761 118 : printf("%d bats total, %d in use, %"PRIu32" free bats in common shared list\n",
4762 : sz - 1, nbats, nfree);
4763 118 : if (nskip > 0)
4764 0 : printf("%d bat slots unaccounted for because of locking\n", nskip);
4765 : }
|
