]> git.sur5r.net Git - openldap/blob - libraries/liblmdb/mdb.c
Comment ~MDB_APPEND, from earlier commit message.
[openldap] / libraries / liblmdb / mdb.c
1 /** @file mdb.c
2  *      @brief memory-mapped database library
3  *
4  *      A Btree-based database management library modeled loosely on the
5  *      BerkeleyDB API, but much simplified.
6  */
7 /*
8  * Copyright 2011-2013 Howard Chu, Symas Corp.
9  * All rights reserved.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted only as authorized by the OpenLDAP
13  * Public License.
14  *
15  * A copy of this license is available in the file LICENSE in the
16  * top-level directory of the distribution or, alternatively, at
17  * <http://www.OpenLDAP.org/license.html>.
18  *
19  * This code is derived from btree.c written by Martin Hedenfalk.
20  *
21  * Copyright (c) 2009, 2010 Martin Hedenfalk <martin@bzero.se>
22  *
23  * Permission to use, copy, modify, and distribute this software for any
24  * purpose with or without fee is hereby granted, provided that the above
25  * copyright notice and this permission notice appear in all copies.
26  *
27  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
28  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
29  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
30  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
31  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
32  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
33  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
34  */
35 #ifndef _GNU_SOURCE
36 #define _GNU_SOURCE 1
37 #endif
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #ifdef _WIN32
41 #include <windows.h>
42 /** getpid() returns int; MinGW defines pid_t but MinGW64 typedefs it
43  *  as int64 which is wrong. MSVC doesn't define it at all, so just
44  *  don't use it.
45  */
46 #define MDB_PID_T       int
47 #ifdef __GNUC__
48 # include <sys/param.h>
49 #else
50 # define LITTLE_ENDIAN  1234
51 # define BIG_ENDIAN     4321
52 # define BYTE_ORDER     LITTLE_ENDIAN
53 # ifndef SSIZE_MAX
54 #  define SSIZE_MAX     INT_MAX
55 # endif
56 #endif
57 #else
58 #define MDB_PID_T       pid_t
59 #include <sys/param.h>
60 #include <sys/uio.h>
61 #include <sys/mman.h>
62 #ifdef HAVE_SYS_FILE_H
63 #include <sys/file.h>
64 #endif
65 #include <fcntl.h>
66 #endif
67
68 #include <errno.h>
69 #include <limits.h>
70 #include <stddef.h>
71 #include <inttypes.h>
72 #include <stdio.h>
73 #include <stdlib.h>
74 #include <string.h>
75 #include <time.h>
76 #include <unistd.h>
77
78 #if !(defined(BYTE_ORDER) || defined(__BYTE_ORDER))
79 #include <netinet/in.h>
80 #include <resolv.h>     /* defines BYTE_ORDER on HPUX and Solaris */
81 #endif
82
83 #if defined(__APPLE__) || defined (BSD)
84 # define MDB_USE_POSIX_SEM      1
85 # define MDB_FDATASYNC          fsync
86 #elif defined(ANDROID)
87 # define MDB_FDATASYNC          fsync
88 #endif
89
90 #ifndef _WIN32
91 #include <pthread.h>
92 #ifdef MDB_USE_POSIX_SEM
93 # define MDB_USE_HASH           1
94 #include <semaphore.h>
95 #endif
96 #endif
97
98 #ifdef USE_VALGRIND
99 #include <valgrind/memcheck.h>
100 #define VGMEMP_CREATE(h,r,z)    VALGRIND_CREATE_MEMPOOL(h,r,z)
101 #define VGMEMP_ALLOC(h,a,s) VALGRIND_MEMPOOL_ALLOC(h,a,s)
102 #define VGMEMP_FREE(h,a) VALGRIND_MEMPOOL_FREE(h,a)
103 #define VGMEMP_DESTROY(h)       VALGRIND_DESTROY_MEMPOOL(h)
104 #define VGMEMP_DEFINED(a,s)     VALGRIND_MAKE_MEM_DEFINED(a,s)
105 #else
106 #define VGMEMP_CREATE(h,r,z)
107 #define VGMEMP_ALLOC(h,a,s)
108 #define VGMEMP_FREE(h,a)
109 #define VGMEMP_DESTROY(h)
110 #define VGMEMP_DEFINED(a,s)
111 #endif
112
113 #ifndef BYTE_ORDER
114 # if (defined(_LITTLE_ENDIAN) || defined(_BIG_ENDIAN)) && !(defined(_LITTLE_ENDIAN) && defined(_BIG_ENDIAN))
115 /* Solaris just defines one or the other */
116 #  define LITTLE_ENDIAN 1234
117 #  define BIG_ENDIAN    4321
118 #  ifdef _LITTLE_ENDIAN
119 #   define BYTE_ORDER  LITTLE_ENDIAN
120 #  else
121 #   define BYTE_ORDER  BIG_ENDIAN
122 #  endif
123 # else
124 #  define BYTE_ORDER   __BYTE_ORDER
125 # endif
126 #endif
127
128 #ifndef LITTLE_ENDIAN
129 #define LITTLE_ENDIAN   __LITTLE_ENDIAN
130 #endif
131 #ifndef BIG_ENDIAN
132 #define BIG_ENDIAN      __BIG_ENDIAN
133 #endif
134
135 #if defined(__i386) || defined(__x86_64) || defined(_M_IX86)
136 #define MISALIGNED_OK   1
137 #endif
138
139 #include "lmdb.h"
140 #include "midl.h"
141
142 #if (BYTE_ORDER == LITTLE_ENDIAN) == (BYTE_ORDER == BIG_ENDIAN)
143 # error "Unknown or unsupported endianness (BYTE_ORDER)"
144 #elif (-6 & 5) || CHAR_BIT != 8 || UINT_MAX < 0xffffffff || ULONG_MAX % 0xFFFF
145 # error "Two's complement, reasonably sized integer types, please"
146 #endif
147
148 /** @defgroup internal  MDB Internals
149  *      @{
150  */
151 /** @defgroup compat    Compatibility Macros
152  *      A bunch of macros to minimize the amount of platform-specific ifdefs
153  *      needed throughout the rest of the code. When the features this library
154  *      needs are similar enough to POSIX to be hidden in a one-or-two line
155  *      replacement, this macro approach is used.
156  *      @{
157  */
158
159         /** Wrapper around __func__, which is a C99 feature */
160 #if __STDC_VERSION__ >= 199901L
161 # define mdb_func_      __func__
162 #elif __GNUC__ >= 2 || _MSC_VER >= 1300
163 # define mdb_func_      __FUNCTION__
164 #else
165 /* If a debug message says <mdb_unknown>(), update the #if statements above */
166 # define mdb_func_      "<mdb_unknown>"
167 #endif
168
169 #ifdef _WIN32
170 #define MDB_USE_HASH    1
171 #define MDB_PIDLOCK     0
172 #define pthread_t       DWORD
173 #define pthread_mutex_t HANDLE
174 #define pthread_key_t   DWORD
175 #define pthread_self()  GetCurrentThreadId()
176 #define pthread_key_create(x,y) \
177         ((*(x) = TlsAlloc()) == TLS_OUT_OF_INDEXES ? ErrCode() : 0)
178 #define pthread_key_delete(x)   TlsFree(x)
179 #define pthread_getspecific(x)  TlsGetValue(x)
180 #define pthread_setspecific(x,y)        (TlsSetValue(x,y) ? 0 : ErrCode())
181 #define pthread_mutex_unlock(x) ReleaseMutex(x)
182 #define pthread_mutex_lock(x)   WaitForSingleObject(x, INFINITE)
183 #define LOCK_MUTEX_R(env)       pthread_mutex_lock((env)->me_rmutex)
184 #define UNLOCK_MUTEX_R(env)     pthread_mutex_unlock((env)->me_rmutex)
185 #define LOCK_MUTEX_W(env)       pthread_mutex_lock((env)->me_wmutex)
186 #define UNLOCK_MUTEX_W(env)     pthread_mutex_unlock((env)->me_wmutex)
187 #define getpid()        GetCurrentProcessId()
188 #define MDB_FDATASYNC(fd)       (!FlushFileBuffers(fd))
189 #define MDB_MSYNC(addr,len,flags)       (!FlushViewOfFile(addr,len))
190 #define ErrCode()       GetLastError()
191 #define GET_PAGESIZE(x) {SYSTEM_INFO si; GetSystemInfo(&si); (x) = si.dwPageSize;}
192 #define close(fd)       (CloseHandle(fd) ? 0 : -1)
193 #define munmap(ptr,len) UnmapViewOfFile(ptr)
194 #ifdef PROCESS_QUERY_LIMITED_INFORMATION
195 #define MDB_PROCESS_QUERY_LIMITED_INFORMATION PROCESS_QUERY_LIMITED_INFORMATION
196 #else
197 #define MDB_PROCESS_QUERY_LIMITED_INFORMATION 0x1000
198 #endif
199 #define Z       "I"
200 #else
201
202 #define Z       "z"                     /**< printf format modifier for size_t */
203
204         /** For MDB_LOCK_FORMAT: True if readers take a pid lock in the lockfile */
205 #define MDB_PIDLOCK                     1
206
207 #ifdef MDB_USE_POSIX_SEM
208
209 #define LOCK_MUTEX_R(env)       mdb_sem_wait((env)->me_rmutex)
210 #define UNLOCK_MUTEX_R(env)     sem_post((env)->me_rmutex)
211 #define LOCK_MUTEX_W(env)       mdb_sem_wait((env)->me_wmutex)
212 #define UNLOCK_MUTEX_W(env)     sem_post((env)->me_wmutex)
213
214 static int
215 mdb_sem_wait(sem_t *sem)
216 {
217    int rc;
218    while ((rc = sem_wait(sem)) && (rc = errno) == EINTR) ;
219    return rc;
220 }
221
222 #else
223         /** Lock the reader mutex.
224          */
225 #define LOCK_MUTEX_R(env)       pthread_mutex_lock(&(env)->me_txns->mti_mutex)
226         /** Unlock the reader mutex.
227          */
228 #define UNLOCK_MUTEX_R(env)     pthread_mutex_unlock(&(env)->me_txns->mti_mutex)
229
230         /** Lock the writer mutex.
231          *      Only a single write transaction is allowed at a time. Other writers
232          *      will block waiting for this mutex.
233          */
234 #define LOCK_MUTEX_W(env)       pthread_mutex_lock(&(env)->me_txns->mti_wmutex)
235         /** Unlock the writer mutex.
236          */
237 #define UNLOCK_MUTEX_W(env)     pthread_mutex_unlock(&(env)->me_txns->mti_wmutex)
238 #endif  /* MDB_USE_POSIX_SEM */
239
240         /** Get the error code for the last failed system function.
241          */
242 #define ErrCode()       errno
243
244         /** An abstraction for a file handle.
245          *      On POSIX systems file handles are small integers. On Windows
246          *      they're opaque pointers.
247          */
248 #define HANDLE  int
249
250         /**     A value for an invalid file handle.
251          *      Mainly used to initialize file variables and signify that they are
252          *      unused.
253          */
254 #define INVALID_HANDLE_VALUE    (-1)
255
256         /** Get the size of a memory page for the system.
257          *      This is the basic size that the platform's memory manager uses, and is
258          *      fundamental to the use of memory-mapped files.
259          */
260 #define GET_PAGESIZE(x) ((x) = sysconf(_SC_PAGE_SIZE))
261 #endif
262
263 #if defined(_WIN32) || defined(MDB_USE_POSIX_SEM)
264 #define MNAME_LEN       32
265 #else
266 #define MNAME_LEN       (sizeof(pthread_mutex_t))
267 #endif
268
269 /** @} */
270
271 #ifndef _WIN32
272 /**     A flag for opening a file and requesting synchronous data writes.
273  *      This is only used when writing a meta page. It's not strictly needed;
274  *      we could just do a normal write and then immediately perform a flush.
275  *      But if this flag is available it saves us an extra system call.
276  *
277  *      @note If O_DSYNC is undefined but exists in /usr/include,
278  * preferably set some compiler flag to get the definition.
279  * Otherwise compile with the less efficient -DMDB_DSYNC=O_SYNC.
280  */
281 #ifndef MDB_DSYNC
282 # define MDB_DSYNC      O_DSYNC
283 #endif
284 #endif
285
286 /** Function for flushing the data of a file. Define this to fsync
287  *      if fdatasync() is not supported.
288  */
289 #ifndef MDB_FDATASYNC
290 # define MDB_FDATASYNC  fdatasync
291 #endif
292
293 #ifndef MDB_MSYNC
294 # define MDB_MSYNC(addr,len,flags)      msync(addr,len,flags)
295 #endif
296
297 #ifndef MS_SYNC
298 #define MS_SYNC 1
299 #endif
300
301 #ifndef MS_ASYNC
302 #define MS_ASYNC        0
303 #endif
304
305         /** A page number in the database.
306          *      Note that 64 bit page numbers are overkill, since pages themselves
307          *      already represent 12-13 bits of addressable memory, and the OS will
308          *      always limit applications to a maximum of 63 bits of address space.
309          *
310          *      @note In the #MDB_node structure, we only store 48 bits of this value,
311          *      which thus limits us to only 60 bits of addressable data.
312          */
313 typedef MDB_ID  pgno_t;
314
315         /** A transaction ID.
316          *      See struct MDB_txn.mt_txnid for details.
317          */
318 typedef MDB_ID  txnid_t;
319
320 /** @defgroup debug     Debug Macros
321  *      @{
322  */
323 #ifndef MDB_DEBUG
324         /**     Enable debug output.  Needs variable argument macros (a C99 feature).
325          *      Set this to 1 for copious tracing. Set to 2 to add dumps of all IDLs
326          *      read from and written to the database (used for free space management).
327          */
328 #define MDB_DEBUG 0
329 #endif
330
331 #if MDB_DEBUG
332 static int mdb_debug;
333 static txnid_t mdb_debug_start;
334
335         /**     Print a debug message with printf formatting.
336          *      Requires double parenthesis around 2 or more args.
337          */
338 # define DPRINTF(args) ((void) ((mdb_debug) && DPRINTF0 args))
339 # define DPRINTF0(fmt, ...) \
340         fprintf(stderr, "%s:%d " fmt "\n", mdb_func_, __LINE__, __VA_ARGS__)
341 #else
342 # define DPRINTF(args)  ((void) 0)
343 #endif
344         /**     Print a debug string.
345          *      The string is printed literally, with no format processing.
346          */
347 #define DPUTS(arg)      DPRINTF(("%s", arg))
348         /** Debuging output value of a cursor DBI: Negative in a sub-cursor. */
349 #define DDBI(mc) \
350         (((mc)->mc_flags & C_SUB) ? -(int)(mc)->mc_dbi : (int)(mc)->mc_dbi)
351 /** @} */
352
353         /**     @brief The maximum size of a database page.
354          *
355          *      This is 32k, since it must fit in #MDB_page.%mp_upper.
356          *
357          *      LMDB will use database pages < OS pages if needed.
358          *      That causes more I/O in write transactions: The OS must
359          *      know (read) the whole page before writing a partial page.
360          *
361          *      Note that we don't currently support Huge pages. On Linux,
362          *      regular data files cannot use Huge pages, and in general
363          *      Huge pages aren't actually pageable. We rely on the OS
364          *      demand-pager to read our data and page it out when memory
365          *      pressure from other processes is high. So until OSs have
366          *      actual paging support for Huge pages, they're not viable.
367          */
368 #define MAX_PAGESIZE     0x8000
369
370         /** The minimum number of keys required in a database page.
371          *      Setting this to a larger value will place a smaller bound on the
372          *      maximum size of a data item. Data items larger than this size will
373          *      be pushed into overflow pages instead of being stored directly in
374          *      the B-tree node. This value used to default to 4. With a page size
375          *      of 4096 bytes that meant that any item larger than 1024 bytes would
376          *      go into an overflow page. That also meant that on average 2-3KB of
377          *      each overflow page was wasted space. The value cannot be lower than
378          *      2 because then there would no longer be a tree structure. With this
379          *      value, items larger than 2KB will go into overflow pages, and on
380          *      average only 1KB will be wasted.
381          */
382 #define MDB_MINKEYS      2
383
384         /**     A stamp that identifies a file as an MDB file.
385          *      There's nothing special about this value other than that it is easily
386          *      recognizable, and it will reflect any byte order mismatches.
387          */
388 #define MDB_MAGIC        0xBEEFC0DE
389
390         /**     The version number for a database's datafile format. */
391 #define MDB_DATA_VERSION         1
392         /**     The version number for a database's lockfile format. */
393 #define MDB_LOCK_VERSION         1
394
395         /**     @brief The max size of a key we can write, or 0 for dynamic max.
396          *
397          *      Define this as 0 to compute the max from the page size.  511
398          *      is default for backwards compat: liblmdb <= 0.9.10 can break
399          *      when modifying a DB with keys/dupsort data bigger than its max.
400          *
401          *      Data items in an #MDB_DUPSORT database are also limited to
402          *      this size, since they're actually keys of a sub-DB.  Keys and
403          *      #MDB_DUPSORT data items must fit on a node in a regular page.
404          */
405 #ifndef MDB_MAXKEYSIZE
406 #define MDB_MAXKEYSIZE   511
407 #endif
408
409         /**     The maximum size of a key we can write to the environment. */
410 #if MDB_MAXKEYSIZE
411 #define ENV_MAXKEY(env) (MDB_MAXKEYSIZE)
412 #else
413 #define ENV_MAXKEY(env) ((env)->me_maxkey)
414 #endif
415
416         /**     @brief The maximum size of a data item.
417          *
418          *      We only store a 32 bit value for node sizes.
419          */
420 #define MAXDATASIZE     0xffffffffUL
421
422 #if MDB_DEBUG
423         /**     Key size which fits in a #DKBUF.
424          *      @ingroup debug
425          */
426 #define DKBUF_MAXKEYSIZE ((MDB_MAXKEYSIZE) > 0 ? (MDB_MAXKEYSIZE) : 511)
427         /**     A key buffer.
428          *      @ingroup debug
429          *      This is used for printing a hex dump of a key's contents.
430          */
431 #define DKBUF   char kbuf[DKBUF_MAXKEYSIZE*2+1]
432         /**     Display a key in hex.
433          *      @ingroup debug
434          *      Invoke a function to display a key in hex.
435          */
436 #define DKEY(x) mdb_dkey(x, kbuf)
437 #else
438 #define DKBUF
439 #define DKEY(x) 0
440 #endif
441
442         /** An invalid page number.
443          *      Mainly used to denote an empty tree.
444          */
445 #define P_INVALID        (~(pgno_t)0)
446
447         /** Test if the flags \b f are set in a flag word \b w. */
448 #define F_ISSET(w, f)    (((w) & (f)) == (f))
449
450         /** Round \b n up to an even number. */
451 #define EVEN(n)         (((n) + 1U) & -2) /* sign-extending -2 to match n+1U */
452
453         /**     Used for offsets within a single page.
454          *      Since memory pages are typically 4 or 8KB in size, 12-13 bits,
455          *      this is plenty.
456          */
457 typedef uint16_t         indx_t;
458
459         /**     Default size of memory map.
460          *      This is certainly too small for any actual applications. Apps should always set
461          *      the size explicitly using #mdb_env_set_mapsize().
462          */
463 #define DEFAULT_MAPSIZE 1048576
464
465 /**     @defgroup readers       Reader Lock Table
466  *      Readers don't acquire any locks for their data access. Instead, they
467  *      simply record their transaction ID in the reader table. The reader
468  *      mutex is needed just to find an empty slot in the reader table. The
469  *      slot's address is saved in thread-specific data so that subsequent read
470  *      transactions started by the same thread need no further locking to proceed.
471  *
472  *      If #MDB_NOTLS is set, the slot address is not saved in thread-specific data.
473  *
474  *      No reader table is used if the database is on a read-only filesystem, or
475  *      if #MDB_NOLOCK is set.
476  *
477  *      Since the database uses multi-version concurrency control, readers don't
478  *      actually need any locking. This table is used to keep track of which
479  *      readers are using data from which old transactions, so that we'll know
480  *      when a particular old transaction is no longer in use. Old transactions
481  *      that have discarded any data pages can then have those pages reclaimed
482  *      for use by a later write transaction.
483  *
484  *      The lock table is constructed such that reader slots are aligned with the
485  *      processor's cache line size. Any slot is only ever used by one thread.
486  *      This alignment guarantees that there will be no contention or cache
487  *      thrashing as threads update their own slot info, and also eliminates
488  *      any need for locking when accessing a slot.
489  *
490  *      A writer thread will scan every slot in the table to determine the oldest
491  *      outstanding reader transaction. Any freed pages older than this will be
492  *      reclaimed by the writer. The writer doesn't use any locks when scanning
493  *      this table. This means that there's no guarantee that the writer will
494  *      see the most up-to-date reader info, but that's not required for correct
495  *      operation - all we need is to know the upper bound on the oldest reader,
496  *      we don't care at all about the newest reader. So the only consequence of
497  *      reading stale information here is that old pages might hang around a
498  *      while longer before being reclaimed. That's actually good anyway, because
499  *      the longer we delay reclaiming old pages, the more likely it is that a
500  *      string of contiguous pages can be found after coalescing old pages from
501  *      many old transactions together.
502  *      @{
503  */
504         /**     Number of slots in the reader table.
505          *      This value was chosen somewhat arbitrarily. 126 readers plus a
506          *      couple mutexes fit exactly into 8KB on my development machine.
507          *      Applications should set the table size using #mdb_env_set_maxreaders().
508          */
509 #define DEFAULT_READERS 126
510
511         /**     The size of a CPU cache line in bytes. We want our lock structures
512          *      aligned to this size to avoid false cache line sharing in the
513          *      lock table.
514          *      This value works for most CPUs. For Itanium this should be 128.
515          */
516 #ifndef CACHELINE
517 #define CACHELINE       64
518 #endif
519
520         /**     The information we store in a single slot of the reader table.
521          *      In addition to a transaction ID, we also record the process and
522          *      thread ID that owns a slot, so that we can detect stale information,
523          *      e.g. threads or processes that went away without cleaning up.
524          *      @note We currently don't check for stale records. We simply re-init
525          *      the table when we know that we're the only process opening the
526          *      lock file.
527          */
528 typedef struct MDB_rxbody {
529         /**     Current Transaction ID when this transaction began, or (txnid_t)-1.
530          *      Multiple readers that start at the same time will probably have the
531          *      same ID here. Again, it's not important to exclude them from
532          *      anything; all we need to know is which version of the DB they
533          *      started from so we can avoid overwriting any data used in that
534          *      particular version.
535          */
536         txnid_t         mrb_txnid;
537         /** The process ID of the process owning this reader txn. */
538         MDB_PID_T       mrb_pid;
539         /** The thread ID of the thread owning this txn. */
540         pthread_t       mrb_tid;
541 } MDB_rxbody;
542
543         /** The actual reader record, with cacheline padding. */
544 typedef struct MDB_reader {
545         union {
546                 MDB_rxbody mrx;
547                 /** shorthand for mrb_txnid */
548 #define mr_txnid        mru.mrx.mrb_txnid
549 #define mr_pid  mru.mrx.mrb_pid
550 #define mr_tid  mru.mrx.mrb_tid
551                 /** cache line alignment */
552                 char pad[(sizeof(MDB_rxbody)+CACHELINE-1) & ~(CACHELINE-1)];
553         } mru;
554 } MDB_reader;
555
556         /** The header for the reader table.
557          *      The table resides in a memory-mapped file. (This is a different file
558          *      than is used for the main database.)
559          *
560          *      For POSIX the actual mutexes reside in the shared memory of this
561          *      mapped file. On Windows, mutexes are named objects allocated by the
562          *      kernel; we store the mutex names in this mapped file so that other
563          *      processes can grab them. This same approach is also used on
564          *      MacOSX/Darwin (using named semaphores) since MacOSX doesn't support
565          *      process-shared POSIX mutexes. For these cases where a named object
566          *      is used, the object name is derived from a 64 bit FNV hash of the
567          *      environment pathname. As such, naming collisions are extremely
568          *      unlikely. If a collision occurs, the results are unpredictable.
569          */
570 typedef struct MDB_txbody {
571                 /** Stamp identifying this as an MDB file. It must be set
572                  *      to #MDB_MAGIC. */
573         uint32_t        mtb_magic;
574                 /** Format of this lock file. Must be set to #MDB_LOCK_FORMAT. */
575         uint32_t        mtb_format;
576 #if defined(_WIN32) || defined(MDB_USE_POSIX_SEM)
577         char    mtb_rmname[MNAME_LEN];
578 #else
579                 /** Mutex protecting access to this table.
580                  *      This is the reader lock that #LOCK_MUTEX_R acquires.
581                  */
582         pthread_mutex_t mtb_mutex;
583 #endif
584                 /**     The ID of the last transaction committed to the database.
585                  *      This is recorded here only for convenience; the value can always
586                  *      be determined by reading the main database meta pages.
587                  */
588         txnid_t         mtb_txnid;
589                 /** The number of slots that have been used in the reader table.
590                  *      This always records the maximum count, it is not decremented
591                  *      when readers release their slots.
592                  */
593         unsigned        mtb_numreaders;
594 } MDB_txbody;
595
596         /** The actual reader table definition. */
597 typedef struct MDB_txninfo {
598         union {
599                 MDB_txbody mtb;
600 #define mti_magic       mt1.mtb.mtb_magic
601 #define mti_format      mt1.mtb.mtb_format
602 #define mti_mutex       mt1.mtb.mtb_mutex
603 #define mti_rmname      mt1.mtb.mtb_rmname
604 #define mti_txnid       mt1.mtb.mtb_txnid
605 #define mti_numreaders  mt1.mtb.mtb_numreaders
606                 char pad[(sizeof(MDB_txbody)+CACHELINE-1) & ~(CACHELINE-1)];
607         } mt1;
608         union {
609 #if defined(_WIN32) || defined(MDB_USE_POSIX_SEM)
610                 char mt2_wmname[MNAME_LEN];
611 #define mti_wmname      mt2.mt2_wmname
612 #else
613                 pthread_mutex_t mt2_wmutex;
614 #define mti_wmutex      mt2.mt2_wmutex
615 #endif
616                 char pad[(MNAME_LEN+CACHELINE-1) & ~(CACHELINE-1)];
617         } mt2;
618         MDB_reader      mti_readers[1];
619 } MDB_txninfo;
620
621         /** Lockfile format signature: version, features and field layout */
622 #define MDB_LOCK_FORMAT \
623         ((uint32_t) \
624          ((MDB_LOCK_VERSION) \
625           /* Flags which describe functionality */ \
626           + (((MDB_PIDLOCK) != 0) << 16)))
627 /** @} */
628
629 /** Common header for all page types.
630  * Overflow records occupy a number of contiguous pages with no
631  * headers on any page after the first.
632  */
633 typedef struct MDB_page {
634 #define mp_pgno mp_p.p_pgno
635 #define mp_next mp_p.p_next
636         union {
637                 pgno_t          p_pgno; /**< page number */
638                 void *          p_next; /**< for in-memory list of freed structs */
639         } mp_p;
640         uint16_t        mp_pad;
641 /**     @defgroup mdb_page      Page Flags
642  *      @ingroup internal
643  *      Flags for the page headers.
644  *      @{
645  */
646 #define P_BRANCH         0x01           /**< branch page */
647 #define P_LEAF           0x02           /**< leaf page */
648 #define P_OVERFLOW       0x04           /**< overflow page */
649 #define P_META           0x08           /**< meta page */
650 #define P_DIRTY          0x10           /**< dirty page, also set for #P_SUBP pages */
651 #define P_LEAF2          0x20           /**< for #MDB_DUPFIXED records */
652 #define P_SUBP           0x40           /**< for #MDB_DUPSORT sub-pages */
653 #define P_KEEP           0x8000         /**< leave this page alone during spill */
654 /** @} */
655         uint16_t        mp_flags;               /**< @ref mdb_page */
656 #define mp_lower        mp_pb.pb.pb_lower
657 #define mp_upper        mp_pb.pb.pb_upper
658 #define mp_pages        mp_pb.pb_pages
659         union {
660                 struct {
661                         indx_t          pb_lower;               /**< lower bound of free space */
662                         indx_t          pb_upper;               /**< upper bound of free space */
663                 } pb;
664                 uint32_t        pb_pages;       /**< number of overflow pages */
665         } mp_pb;
666         indx_t          mp_ptrs[1];             /**< dynamic size */
667 } MDB_page;
668
669         /** Size of the page header, excluding dynamic data at the end */
670 #define PAGEHDRSZ        ((unsigned) offsetof(MDB_page, mp_ptrs))
671
672         /** Address of first usable data byte in a page, after the header */
673 #define METADATA(p)      ((void *)((char *)(p) + PAGEHDRSZ))
674
675         /** Number of nodes on a page */
676 #define NUMKEYS(p)       (((p)->mp_lower - PAGEHDRSZ) >> 1)
677
678         /** The amount of space remaining in the page */
679 #define SIZELEFT(p)      (indx_t)((p)->mp_upper - (p)->mp_lower)
680
681         /** The percentage of space used in the page, in tenths of a percent. */
682 #define PAGEFILL(env, p) (1000L * ((env)->me_psize - PAGEHDRSZ - SIZELEFT(p)) / \
683                                 ((env)->me_psize - PAGEHDRSZ))
684         /** The minimum page fill factor, in tenths of a percent.
685          *      Pages emptier than this are candidates for merging.
686          */
687 #define FILL_THRESHOLD   250
688
689         /** Test if a page is a leaf page */
690 #define IS_LEAF(p)       F_ISSET((p)->mp_flags, P_LEAF)
691         /** Test if a page is a LEAF2 page */
692 #define IS_LEAF2(p)      F_ISSET((p)->mp_flags, P_LEAF2)
693         /** Test if a page is a branch page */
694 #define IS_BRANCH(p)     F_ISSET((p)->mp_flags, P_BRANCH)
695         /** Test if a page is an overflow page */
696 #define IS_OVERFLOW(p)   F_ISSET((p)->mp_flags, P_OVERFLOW)
697         /** Test if a page is a sub page */
698 #define IS_SUBP(p)       F_ISSET((p)->mp_flags, P_SUBP)
699
700         /** The number of overflow pages needed to store the given size. */
701 #define OVPAGES(size, psize)    ((PAGEHDRSZ-1 + (size)) / (psize) + 1)
702
703         /** Header for a single key/data pair within a page.
704          * Used in pages of type #P_BRANCH and #P_LEAF without #P_LEAF2.
705          * We guarantee 2-byte alignment for 'MDB_node's.
706          */
707 typedef struct MDB_node {
708         /** lo and hi are used for data size on leaf nodes and for
709          * child pgno on branch nodes. On 64 bit platforms, flags
710          * is also used for pgno. (Branch nodes have no flags).
711          * They are in host byte order in case that lets some
712          * accesses be optimized into a 32-bit word access.
713          */
714 #if BYTE_ORDER == LITTLE_ENDIAN
715         unsigned short  mn_lo, mn_hi;   /**< part of data size or pgno */
716 #else
717         unsigned short  mn_hi, mn_lo;
718 #endif
719 /** @defgroup mdb_node Node Flags
720  *      @ingroup internal
721  *      Flags for node headers.
722  *      @{
723  */
724 #define F_BIGDATA        0x01                   /**< data put on overflow page */
725 #define F_SUBDATA        0x02                   /**< data is a sub-database */
726 #define F_DUPDATA        0x04                   /**< data has duplicates */
727
728 /** valid flags for #mdb_node_add() */
729 #define NODE_ADD_FLAGS  (F_DUPDATA|F_SUBDATA|MDB_RESERVE|MDB_APPEND)
730
731 /** @} */
732         unsigned short  mn_flags;               /**< @ref mdb_node */
733         unsigned short  mn_ksize;               /**< key size */
734         char            mn_data[1];                     /**< key and data are appended here */
735 } MDB_node;
736
737         /** Size of the node header, excluding dynamic data at the end */
738 #define NODESIZE         offsetof(MDB_node, mn_data)
739
740         /** Bit position of top word in page number, for shifting mn_flags */
741 #define PGNO_TOPWORD ((pgno_t)-1 > 0xffffffffu ? 32 : 0)
742
743         /** Size of a node in a branch page with a given key.
744          *      This is just the node header plus the key, there is no data.
745          */
746 #define INDXSIZE(k)      (NODESIZE + ((k) == NULL ? 0 : (k)->mv_size))
747
748         /** Size of a node in a leaf page with a given key and data.
749          *      This is node header plus key plus data size.
750          */
751 #define LEAFSIZE(k, d)   (NODESIZE + (k)->mv_size + (d)->mv_size)
752
753         /** Address of node \b i in page \b p */
754 #define NODEPTR(p, i)    ((MDB_node *)((char *)(p) + (p)->mp_ptrs[i]))
755
756         /** Address of the key for the node */
757 #define NODEKEY(node)    (void *)((node)->mn_data)
758
759         /** Address of the data for a node */
760 #define NODEDATA(node)   (void *)((char *)(node)->mn_data + (node)->mn_ksize)
761
762         /** Get the page number pointed to by a branch node */
763 #define NODEPGNO(node) \
764         ((node)->mn_lo | ((pgno_t) (node)->mn_hi << 16) | \
765          (PGNO_TOPWORD ? ((pgno_t) (node)->mn_flags << PGNO_TOPWORD) : 0))
766         /** Set the page number in a branch node */
767 #define SETPGNO(node,pgno)      do { \
768         (node)->mn_lo = (pgno) & 0xffff; (node)->mn_hi = (pgno) >> 16; \
769         if (PGNO_TOPWORD) (node)->mn_flags = (pgno) >> PGNO_TOPWORD; } while(0)
770
771         /** Get the size of the data in a leaf node */
772 #define NODEDSZ(node)    ((node)->mn_lo | ((unsigned)(node)->mn_hi << 16))
773         /** Set the size of the data for a leaf node */
774 #define SETDSZ(node,size)       do { \
775         (node)->mn_lo = (size) & 0xffff; (node)->mn_hi = (size) >> 16;} while(0)
776         /** The size of a key in a node */
777 #define NODEKSZ(node)    ((node)->mn_ksize)
778
779         /** Copy a page number from src to dst */
780 #ifdef MISALIGNED_OK
781 #define COPY_PGNO(dst,src)      dst = src
782 #else
783 #if SIZE_MAX > 4294967295UL
784 #define COPY_PGNO(dst,src)      do { \
785         unsigned short *s, *d;  \
786         s = (unsigned short *)&(src);   \
787         d = (unsigned short *)&(dst);   \
788         *d++ = *s++;    \
789         *d++ = *s++;    \
790         *d++ = *s++;    \
791         *d = *s;        \
792 } while (0)
793 #else
794 #define COPY_PGNO(dst,src)      do { \
795         unsigned short *s, *d;  \
796         s = (unsigned short *)&(src);   \
797         d = (unsigned short *)&(dst);   \
798         *d++ = *s++;    \
799         *d = *s;        \
800 } while (0)
801 #endif
802 #endif
803         /** The address of a key in a LEAF2 page.
804          *      LEAF2 pages are used for #MDB_DUPFIXED sorted-duplicate sub-DBs.
805          *      There are no node headers, keys are stored contiguously.
806          */
807 #define LEAF2KEY(p, i, ks)      ((char *)(p) + PAGEHDRSZ + ((i)*(ks)))
808
809         /** Set the \b node's key into \b keyptr, if requested. */
810 #define MDB_GET_KEY(node, keyptr)       { if ((keyptr) != NULL) { \
811         (keyptr)->mv_size = NODEKSZ(node); (keyptr)->mv_data = NODEKEY(node); } }
812
813         /** Set the \b node's key into \b key. */
814 #define MDB_GET_KEY2(node, key) { key.mv_size = NODEKSZ(node); key.mv_data = NODEKEY(node); }
815
816         /** Information about a single database in the environment. */
817 typedef struct MDB_db {
818         uint32_t        md_pad;         /**< also ksize for LEAF2 pages */
819         uint16_t        md_flags;       /**< @ref mdb_dbi_open */
820         uint16_t        md_depth;       /**< depth of this tree */
821         pgno_t          md_branch_pages;        /**< number of internal pages */
822         pgno_t          md_leaf_pages;          /**< number of leaf pages */
823         pgno_t          md_overflow_pages;      /**< number of overflow pages */
824         size_t          md_entries;             /**< number of data items */
825         pgno_t          md_root;                /**< the root page of this tree */
826 } MDB_db;
827
828         /** mdb_dbi_open flags */
829 #define MDB_VALID       0x8000          /**< DB handle is valid, for me_dbflags */
830 #define PERSISTENT_FLAGS        (0xffff & ~(MDB_VALID))
831 #define VALID_FLAGS     (MDB_REVERSEKEY|MDB_DUPSORT|MDB_INTEGERKEY|MDB_DUPFIXED|\
832         MDB_INTEGERDUP|MDB_REVERSEDUP|MDB_CREATE)
833
834         /** Handle for the DB used to track free pages. */
835 #define FREE_DBI        0
836         /** Handle for the default DB. */
837 #define MAIN_DBI        1
838
839         /** Meta page content.
840          *      A meta page is the start point for accessing a database snapshot.
841          *      Pages 0-1 are meta pages. Transaction N writes meta page #(N % 2).
842          */
843 typedef struct MDB_meta {
844                 /** Stamp identifying this as an MDB file. It must be set
845                  *      to #MDB_MAGIC. */
846         uint32_t        mm_magic;
847                 /** Version number of this lock file. Must be set to #MDB_DATA_VERSION. */
848         uint32_t        mm_version;
849         void            *mm_address;            /**< address for fixed mapping */
850         size_t          mm_mapsize;                     /**< size of mmap region */
851         MDB_db          mm_dbs[2];                      /**< first is free space, 2nd is main db */
852         /** The size of pages used in this DB */
853 #define mm_psize        mm_dbs[0].md_pad
854         /** Any persistent environment flags. @ref mdb_env */
855 #define mm_flags        mm_dbs[0].md_flags
856         pgno_t          mm_last_pg;                     /**< last used page in file */
857         txnid_t         mm_txnid;                       /**< txnid that committed this page */
858 } MDB_meta;
859
860         /** Buffer for a stack-allocated meta page.
861          *      The members define size and alignment, and silence type
862          *      aliasing warnings.  They are not used directly; that could
863          *      mean incorrectly using several union members in parallel.
864          */
865 typedef union MDB_metabuf {
866         MDB_page        mb_page;
867         struct {
868                 char            mm_pad[PAGEHDRSZ];
869                 MDB_meta        mm_meta;
870         } mb_metabuf;
871 } MDB_metabuf;
872
873         /** Auxiliary DB info.
874          *      The information here is mostly static/read-only. There is
875          *      only a single copy of this record in the environment.
876          */
877 typedef struct MDB_dbx {
878         MDB_val         md_name;                /**< name of the database */
879         MDB_cmp_func    *md_cmp;        /**< function for comparing keys */
880         MDB_cmp_func    *md_dcmp;       /**< function for comparing data items */
881         MDB_rel_func    *md_rel;        /**< user relocate function */
882         void            *md_relctx;             /**< user-provided context for md_rel */
883 } MDB_dbx;
884
885         /** A database transaction.
886          *      Every operation requires a transaction handle.
887          */
888 struct MDB_txn {
889         MDB_txn         *mt_parent;             /**< parent of a nested txn */
890         MDB_txn         *mt_child;              /**< nested txn under this txn */
891         pgno_t          mt_next_pgno;   /**< next unallocated page */
892         /** The ID of this transaction. IDs are integers incrementing from 1.
893          *      Only committed write transactions increment the ID. If a transaction
894          *      aborts, the ID may be re-used by the next writer.
895          */
896         txnid_t         mt_txnid;
897         MDB_env         *mt_env;                /**< the DB environment */
898         /** The list of pages that became unused during this transaction.
899          */
900         MDB_IDL         mt_free_pgs;
901         /** The sorted list of dirty pages we temporarily wrote to disk
902          *      because the dirty list was full. page numbers in here are
903          *      shifted left by 1, deleted slots have the LSB set.
904          */
905         MDB_IDL         mt_spill_pgs;
906         union {
907                 /** For write txns: Modified pages. Sorted when not MDB_WRITEMAP. */
908                 MDB_ID2L        dirty_list;
909                 /** For read txns: This thread/txn's reader table slot, or NULL. */
910                 MDB_reader      *reader;
911         } mt_u;
912         /** Array of records for each DB known in the environment. */
913         MDB_dbx         *mt_dbxs;
914         /** Array of MDB_db records for each known DB */
915         MDB_db          *mt_dbs;
916 /** @defgroup mt_dbflag Transaction DB Flags
917  *      @ingroup internal
918  * @{
919  */
920 #define DB_DIRTY        0x01            /**< DB was modified or is DUPSORT data */
921 #define DB_STALE        0x02            /**< Named-DB record is older than txnID */
922 #define DB_NEW          0x04            /**< Named-DB handle opened in this txn */
923 #define DB_VALID        0x08            /**< DB handle is valid, see also #MDB_VALID */
924 /** @} */
925         /** In write txns, array of cursors for each DB */
926         MDB_cursor      **mt_cursors;
927         /** Array of flags for each DB */
928         unsigned char   *mt_dbflags;
929         /**     Number of DB records in use. This number only ever increments;
930          *      we don't decrement it when individual DB handles are closed.
931          */
932         MDB_dbi         mt_numdbs;
933
934 /** @defgroup mdb_txn   Transaction Flags
935  *      @ingroup internal
936  *      @{
937  */
938 #define MDB_TXN_RDONLY          0x01            /**< read-only transaction */
939 #define MDB_TXN_ERROR           0x02            /**< txn is unusable after an error */
940 #define MDB_TXN_DIRTY           0x04            /**< must write, even if dirty list is empty */
941 #define MDB_TXN_SPILLS          0x08            /**< txn or a parent has spilled pages */
942 /** @} */
943         unsigned int    mt_flags;               /**< @ref mdb_txn */
944         /** #dirty_list room: Array size - \#dirty pages visible to this txn.
945          *      Includes ancestor txns' dirty pages not hidden by other txns'
946          *      dirty/spilled pages. Thus commit(nested txn) has room to merge
947          *      dirty_list into mt_parent after freeing hidden mt_parent pages.
948          */
949         unsigned int    mt_dirty_room;
950 };
951
952 /** Enough space for 2^32 nodes with minimum of 2 keys per node. I.e., plenty.
953  * At 4 keys per node, enough for 2^64 nodes, so there's probably no need to
954  * raise this on a 64 bit machine.
955  */
956 #define CURSOR_STACK             32
957
958 struct MDB_xcursor;
959
960         /** Cursors are used for all DB operations.
961          *      A cursor holds a path of (page pointer, key index) from the DB
962          *      root to a position in the DB, plus other state. #MDB_DUPSORT
963          *      cursors include an xcursor to the current data item. Write txns
964          *      track their cursors and keep them up to date when data moves.
965          *      Exception: An xcursor's pointer to a #P_SUBP page can be stale.
966          *      (A node with #F_DUPDATA but no #F_SUBDATA contains a subpage).
967          */
968 struct MDB_cursor {
969         /** Next cursor on this DB in this txn */
970         MDB_cursor      *mc_next;
971         /** Backup of the original cursor if this cursor is a shadow */
972         MDB_cursor      *mc_backup;
973         /** Context used for databases with #MDB_DUPSORT, otherwise NULL */
974         struct MDB_xcursor      *mc_xcursor;
975         /** The transaction that owns this cursor */
976         MDB_txn         *mc_txn;
977         /** The database handle this cursor operates on */
978         MDB_dbi         mc_dbi;
979         /** The database record for this cursor */
980         MDB_db          *mc_db;
981         /** The database auxiliary record for this cursor */
982         MDB_dbx         *mc_dbx;
983         /** The @ref mt_dbflag for this database */
984         unsigned char   *mc_dbflag;
985         unsigned short  mc_snum;        /**< number of pushed pages */
986         unsigned short  mc_top;         /**< index of top page, normally mc_snum-1 */
987 /** @defgroup mdb_cursor        Cursor Flags
988  *      @ingroup internal
989  *      Cursor state flags.
990  *      @{
991  */
992 #define C_INITIALIZED   0x01    /**< cursor has been initialized and is valid */
993 #define C_EOF   0x02                    /**< No more data */
994 #define C_SUB   0x04                    /**< Cursor is a sub-cursor */
995 #define C_DEL   0x08                    /**< last op was a cursor_del */
996 #define C_SPLITTING     0x20            /**< Cursor is in page_split */
997 #define C_UNTRACK       0x40            /**< Un-track cursor when closing */
998 /** @} */
999         unsigned int    mc_flags;       /**< @ref mdb_cursor */
1000         MDB_page        *mc_pg[CURSOR_STACK];   /**< stack of pushed pages */
1001         indx_t          mc_ki[CURSOR_STACK];    /**< stack of page indices */
1002 };
1003
1004         /** Context for sorted-dup records.
1005          *      We could have gone to a fully recursive design, with arbitrarily
1006          *      deep nesting of sub-databases. But for now we only handle these
1007          *      levels - main DB, optional sub-DB, sorted-duplicate DB.
1008          */
1009 typedef struct MDB_xcursor {
1010         /** A sub-cursor for traversing the Dup DB */
1011         MDB_cursor mx_cursor;
1012         /** The database record for this Dup DB */
1013         MDB_db  mx_db;
1014         /**     The auxiliary DB record for this Dup DB */
1015         MDB_dbx mx_dbx;
1016         /** The @ref mt_dbflag for this Dup DB */
1017         unsigned char mx_dbflag;
1018 } MDB_xcursor;
1019
1020         /** State of FreeDB old pages, stored in the MDB_env */
1021 typedef struct MDB_pgstate {
1022         pgno_t          *mf_pghead;     /**< Reclaimed freeDB pages, or NULL before use */
1023         txnid_t         mf_pglast;      /**< ID of last used record, or 0 if !mf_pghead */
1024 } MDB_pgstate;
1025
1026         /** The database environment. */
1027 struct MDB_env {
1028         HANDLE          me_fd;          /**< The main data file */
1029         HANDLE          me_lfd;         /**< The lock file */
1030         HANDLE          me_mfd;                 /**< just for writing the meta pages */
1031         /** Failed to update the meta page. Probably an I/O error. */
1032 #define MDB_FATAL_ERROR 0x80000000U
1033         /** Some fields are initialized. */
1034 #define MDB_ENV_ACTIVE  0x20000000U
1035         /** me_txkey is set */
1036 #define MDB_ENV_TXKEY   0x10000000U
1037         uint32_t        me_flags;               /**< @ref mdb_env */
1038         unsigned int    me_psize;       /**< DB page size, inited from me_os_psize */
1039         unsigned int    me_os_psize;    /**< OS page size, from #GET_PAGESIZE */
1040         unsigned int    me_maxreaders;  /**< size of the reader table */
1041         unsigned int    me_numreaders;  /**< max numreaders set by this env */
1042         MDB_dbi         me_numdbs;              /**< number of DBs opened */
1043         MDB_dbi         me_maxdbs;              /**< size of the DB table */
1044         MDB_PID_T       me_pid;         /**< process ID of this env */
1045         char            *me_path;               /**< path to the DB files */
1046         char            *me_map;                /**< the memory map of the data file */
1047         MDB_txninfo     *me_txns;               /**< the memory map of the lock file or NULL */
1048         MDB_meta        *me_metas[2];   /**< pointers to the two meta pages */
1049         void            *me_pbuf;               /**< scratch area for DUPSORT put() */
1050         MDB_txn         *me_txn;                /**< current write transaction */
1051         size_t          me_mapsize;             /**< size of the data memory map */
1052         off_t           me_size;                /**< current file size */
1053         pgno_t          me_maxpg;               /**< me_mapsize / me_psize */
1054         MDB_dbx         *me_dbxs;               /**< array of static DB info */
1055         uint16_t        *me_dbflags;    /**< array of flags from MDB_db.md_flags */
1056         pthread_key_t   me_txkey;       /**< thread-key for readers */
1057         MDB_pgstate     me_pgstate;             /**< state of old pages from freeDB */
1058 #       define          me_pglast       me_pgstate.mf_pglast
1059 #       define          me_pghead       me_pgstate.mf_pghead
1060         MDB_page        *me_dpages;             /**< list of malloc'd blocks for re-use */
1061         /** IDL of pages that became unused in a write txn */
1062         MDB_IDL         me_free_pgs;
1063         /** ID2L of pages written during a write txn. Length MDB_IDL_UM_SIZE. */
1064         MDB_ID2L        me_dirty_list;
1065         /** Max number of freelist items that can fit in a single overflow page */
1066         int                     me_maxfree_1pg;
1067         /** Max size of a node on a page */
1068         unsigned int    me_nodemax;
1069 #if !(MDB_MAXKEYSIZE)
1070         unsigned int    me_maxkey;      /**< max size of a key */
1071 #endif
1072         int             me_live_reader;         /**< have liveness lock in reader table */
1073 #ifdef _WIN32
1074         int             me_pidquery;            /**< Used in OpenProcess */
1075         HANDLE          me_rmutex;              /* Windows mutexes don't reside in shared mem */
1076         HANDLE          me_wmutex;
1077 #elif defined(MDB_USE_POSIX_SEM)
1078         sem_t           *me_rmutex;             /* Shared mutexes are not supported */
1079         sem_t           *me_wmutex;
1080 #endif
1081         void            *me_userctx;     /**< User-settable context */
1082         MDB_assert_func *me_assert_func; /**< Callback for assertion failures */
1083 };
1084
1085         /** Nested transaction */
1086 typedef struct MDB_ntxn {
1087         MDB_txn         mnt_txn;                /**< the transaction */
1088         MDB_pgstate     mnt_pgstate;    /**< parent transaction's saved freestate */
1089 } MDB_ntxn;
1090
1091         /** max number of pages to commit in one writev() call */
1092 #define MDB_COMMIT_PAGES         64
1093 #if defined(IOV_MAX) && IOV_MAX < MDB_COMMIT_PAGES
1094 #undef MDB_COMMIT_PAGES
1095 #define MDB_COMMIT_PAGES        IOV_MAX
1096 #endif
1097
1098         /** max bytes to write in one call */
1099 #define MAX_WRITE               (0x80000000U >> (sizeof(ssize_t) == 4))
1100
1101         /** Check \b txn and \b dbi arguments to a function */
1102 #define TXN_DBI_EXIST(txn, dbi) \
1103         ((txn) && (dbi) < (txn)->mt_numdbs && ((txn)->mt_dbflags[dbi] & DB_VALID))
1104
1105 static int  mdb_page_alloc(MDB_cursor *mc, int num, MDB_page **mp);
1106 static int  mdb_page_new(MDB_cursor *mc, uint32_t flags, int num, MDB_page **mp);
1107 static int  mdb_page_touch(MDB_cursor *mc);
1108
1109 static int  mdb_page_get(MDB_txn *txn, pgno_t pgno, MDB_page **mp, int *lvl);
1110 static int  mdb_page_search_root(MDB_cursor *mc,
1111                             MDB_val *key, int modify);
1112 #define MDB_PS_MODIFY   1
1113 #define MDB_PS_ROOTONLY 2
1114 #define MDB_PS_FIRST    4
1115 #define MDB_PS_LAST             8
1116 static int  mdb_page_search(MDB_cursor *mc,
1117                             MDB_val *key, int flags);
1118 static int      mdb_page_merge(MDB_cursor *csrc, MDB_cursor *cdst);
1119
1120 #define MDB_SPLIT_REPLACE       MDB_APPENDDUP   /**< newkey is not new */
1121 static int      mdb_page_split(MDB_cursor *mc, MDB_val *newkey, MDB_val *newdata,
1122                                 pgno_t newpgno, unsigned int nflags);
1123
1124 static int  mdb_env_read_header(MDB_env *env, MDB_meta *meta);
1125 static int  mdb_env_pick_meta(const MDB_env *env);
1126 static int  mdb_env_write_meta(MDB_txn *txn);
1127 #if !(defined(_WIN32) || defined(MDB_USE_POSIX_SEM)) /* Drop unused excl arg */
1128 # define mdb_env_close0(env, excl) mdb_env_close1(env)
1129 #endif
1130 static void mdb_env_close0(MDB_env *env, int excl);
1131
1132 static MDB_node *mdb_node_search(MDB_cursor *mc, MDB_val *key, int *exactp);
1133 static int  mdb_node_add(MDB_cursor *mc, indx_t indx,
1134                             MDB_val *key, MDB_val *data, pgno_t pgno, unsigned int flags);
1135 static void mdb_node_del(MDB_cursor *mc, int ksize);
1136 static void mdb_node_shrink(MDB_page *mp, indx_t indx);
1137 static int      mdb_node_move(MDB_cursor *csrc, MDB_cursor *cdst);
1138 static int  mdb_node_read(MDB_txn *txn, MDB_node *leaf, MDB_val *data);
1139 static size_t   mdb_leaf_size(MDB_env *env, MDB_val *key, MDB_val *data);
1140 static size_t   mdb_branch_size(MDB_env *env, MDB_val *key);
1141
1142 static int      mdb_rebalance(MDB_cursor *mc);
1143 static int      mdb_update_key(MDB_cursor *mc, MDB_val *key);
1144
1145 static void     mdb_cursor_pop(MDB_cursor *mc);
1146 static int      mdb_cursor_push(MDB_cursor *mc, MDB_page *mp);
1147
1148 static int      mdb_cursor_del0(MDB_cursor *mc);
1149 static int      mdb_del0(MDB_txn *txn, MDB_dbi dbi, MDB_val *key, MDB_val *data, unsigned flags);
1150 static int      mdb_cursor_sibling(MDB_cursor *mc, int move_right);
1151 static int      mdb_cursor_next(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op);
1152 static int      mdb_cursor_prev(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op);
1153 static int      mdb_cursor_set(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op,
1154                                 int *exactp);
1155 static int      mdb_cursor_first(MDB_cursor *mc, MDB_val *key, MDB_val *data);
1156 static int      mdb_cursor_last(MDB_cursor *mc, MDB_val *key, MDB_val *data);
1157
1158 static void     mdb_cursor_init(MDB_cursor *mc, MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx);
1159 static void     mdb_xcursor_init0(MDB_cursor *mc);
1160 static void     mdb_xcursor_init1(MDB_cursor *mc, MDB_node *node);
1161
1162 static int      mdb_drop0(MDB_cursor *mc, int subs);
1163 static void mdb_default_cmp(MDB_txn *txn, MDB_dbi dbi);
1164
1165 /** @cond */
1166 static MDB_cmp_func     mdb_cmp_memn, mdb_cmp_memnr, mdb_cmp_int, mdb_cmp_cint, mdb_cmp_long;
1167 /** @endcond */
1168
1169 #ifdef _WIN32
1170 static SECURITY_DESCRIPTOR mdb_null_sd;
1171 static SECURITY_ATTRIBUTES mdb_all_sa;
1172 static int mdb_sec_inited;
1173 #endif
1174
1175 /** Return the library version info. */
1176 char *
1177 mdb_version(int *major, int *minor, int *patch)
1178 {
1179         if (major) *major = MDB_VERSION_MAJOR;
1180         if (minor) *minor = MDB_VERSION_MINOR;
1181         if (patch) *patch = MDB_VERSION_PATCH;
1182         return MDB_VERSION_STRING;
1183 }
1184
1185 /** Table of descriptions for MDB @ref errors */
1186 static char *const mdb_errstr[] = {
1187         "MDB_KEYEXIST: Key/data pair already exists",
1188         "MDB_NOTFOUND: No matching key/data pair found",
1189         "MDB_PAGE_NOTFOUND: Requested page not found",
1190         "MDB_CORRUPTED: Located page was wrong type",
1191         "MDB_PANIC: Update of meta page failed",
1192         "MDB_VERSION_MISMATCH: Database environment version mismatch",
1193         "MDB_INVALID: File is not an MDB file",
1194         "MDB_MAP_FULL: Environment mapsize limit reached",
1195         "MDB_DBS_FULL: Environment maxdbs limit reached",
1196         "MDB_READERS_FULL: Environment maxreaders limit reached",
1197         "MDB_TLS_FULL: Thread-local storage keys full - too many environments open",
1198         "MDB_TXN_FULL: Transaction has too many dirty pages - transaction too big",
1199         "MDB_CURSOR_FULL: Internal error - cursor stack limit reached",
1200         "MDB_PAGE_FULL: Internal error - page has no more space",
1201         "MDB_MAP_RESIZED: Database contents grew beyond environment mapsize",
1202         "MDB_INCOMPATIBLE: Operation and DB incompatible, or DB flags changed",
1203         "MDB_BAD_RSLOT: Invalid reuse of reader locktable slot",
1204         "MDB_BAD_TXN: Transaction cannot recover - it must be aborted",
1205         "MDB_BAD_VALSIZE: Unsupported size of key/DB name/data, or wrong DUPFIXED size",
1206 };
1207
1208 char *
1209 mdb_strerror(int err)
1210 {
1211         int i;
1212         if (!err)
1213                 return ("Successful return: 0");
1214
1215         if (err >= MDB_KEYEXIST && err <= MDB_LAST_ERRCODE) {
1216                 i = err - MDB_KEYEXIST;
1217                 return mdb_errstr[i];
1218         }
1219
1220         return strerror(err);
1221 }
1222
1223 /** assert(3) variant in cursor context */
1224 #define mdb_cassert(mc, expr)   mdb_assert0((mc)->mc_txn->mt_env, expr, #expr)
1225 /** assert(3) variant in transaction context */
1226 #define mdb_tassert(mc, expr)   mdb_assert0((txn)->mt_env, expr, #expr)
1227 /** assert(3) variant in environment context */
1228 #define mdb_eassert(env, expr)  mdb_assert0(env, expr, #expr)
1229
1230 #ifndef NDEBUG
1231 # define mdb_assert0(env, expr, expr_txt) ((expr) ? (void)0 : \
1232                 mdb_assert_fail(env, expr_txt, mdb_func_, __FILE__, __LINE__))
1233
1234 static void
1235 mdb_assert_fail(MDB_env *env, const char *expr_txt,
1236         const char *func, const char *file, int line)
1237 {
1238         char buf[400];
1239         sprintf(buf, "%.100s:%d: Assertion '%.200s' failed in %.40s()",
1240                 file, line, expr_txt, func);
1241         if (env->me_assert_func)
1242                 env->me_assert_func(env, buf);
1243         fprintf(stderr, "%s\n", buf);
1244         abort();
1245 }
1246 #else
1247 # define mdb_assert0(env, expr, expr_txt) ((void) 0)
1248 #endif /* NDEBUG */
1249
1250 #if MDB_DEBUG
1251 /** Return the page number of \b mp which may be sub-page, for debug output */
1252 static pgno_t
1253 mdb_dbg_pgno(MDB_page *mp)
1254 {
1255         pgno_t ret;
1256         COPY_PGNO(ret, mp->mp_pgno);
1257         return ret;
1258 }
1259
1260 /** Display a key in hexadecimal and return the address of the result.
1261  * @param[in] key the key to display
1262  * @param[in] buf the buffer to write into. Should always be #DKBUF.
1263  * @return The key in hexadecimal form.
1264  */
1265 char *
1266 mdb_dkey(MDB_val *key, char *buf)
1267 {
1268         char *ptr = buf;
1269         unsigned char *c = key->mv_data;
1270         unsigned int i;
1271
1272         if (!key)
1273                 return "";
1274
1275         if (key->mv_size > DKBUF_MAXKEYSIZE)
1276                 return "MDB_MAXKEYSIZE";
1277         /* may want to make this a dynamic check: if the key is mostly
1278          * printable characters, print it as-is instead of converting to hex.
1279          */
1280 #if 1
1281         buf[0] = '\0';
1282         for (i=0; i<key->mv_size; i++)
1283                 ptr += sprintf(ptr, "%02x", *c++);
1284 #else
1285         sprintf(buf, "%.*s", key->mv_size, key->mv_data);
1286 #endif
1287         return buf;
1288 }
1289
1290 static const char *
1291 mdb_leafnode_type(MDB_node *n)
1292 {
1293         static char *const tp[2][2] = {{"", ": DB"}, {": sub-page", ": sub-DB"}};
1294         return F_ISSET(n->mn_flags, F_BIGDATA) ? ": overflow page" :
1295                 tp[F_ISSET(n->mn_flags, F_DUPDATA)][F_ISSET(n->mn_flags, F_SUBDATA)];
1296 }
1297
1298 /** Display all the keys in the page. */
1299 void
1300 mdb_page_list(MDB_page *mp)
1301 {
1302         pgno_t pgno = mdb_dbg_pgno(mp);
1303         const char *type, *state = (mp->mp_flags & P_DIRTY) ? ", dirty" : "";
1304         MDB_node *node;
1305         unsigned int i, nkeys, nsize, total = 0;
1306         MDB_val key;
1307         DKBUF;
1308
1309         switch (mp->mp_flags & (P_BRANCH|P_LEAF|P_LEAF2|P_META|P_OVERFLOW|P_SUBP)) {
1310         case P_BRANCH:              type = "Branch page";               break;
1311         case P_LEAF:                type = "Leaf page";                 break;
1312         case P_LEAF|P_SUBP:         type = "Sub-page";                  break;
1313         case P_LEAF|P_LEAF2:        type = "LEAF2 page";                break;
1314         case P_LEAF|P_LEAF2|P_SUBP: type = "LEAF2 sub-page";    break;
1315         case P_OVERFLOW:
1316                 fprintf(stderr, "Overflow page %"Z"u pages %u%s\n",
1317                         pgno, mp->mp_pages, state);
1318                 return;
1319         case P_META:
1320                 fprintf(stderr, "Meta-page %"Z"u txnid %"Z"u\n",
1321                         pgno, ((MDB_meta *)METADATA(mp))->mm_txnid);
1322                 return;
1323         default:
1324                 fprintf(stderr, "Bad page %"Z"u flags 0x%u\n", pgno, mp->mp_flags);
1325                 return;
1326         }
1327
1328         nkeys = NUMKEYS(mp);
1329         fprintf(stderr, "%s %"Z"u numkeys %d%s\n", type, pgno, nkeys, state);
1330
1331         for (i=0; i<nkeys; i++) {
1332                 if (IS_LEAF2(mp)) {     /* LEAF2 pages have no mp_ptrs[] or node headers */
1333                         key.mv_size = nsize = mp->mp_pad;
1334                         key.mv_data = LEAF2KEY(mp, i, nsize);
1335                         total += nsize;
1336                         fprintf(stderr, "key %d: nsize %d, %s\n", i, nsize, DKEY(&key));
1337                         continue;
1338                 }
1339                 node = NODEPTR(mp, i);
1340                 key.mv_size = node->mn_ksize;
1341                 key.mv_data = node->mn_data;
1342                 nsize = NODESIZE + key.mv_size;
1343                 if (IS_BRANCH(mp)) {
1344                         fprintf(stderr, "key %d: page %"Z"u, %s\n", i, NODEPGNO(node),
1345                                 DKEY(&key));
1346                         total += nsize;
1347                 } else {
1348                         if (F_ISSET(node->mn_flags, F_BIGDATA))
1349                                 nsize += sizeof(pgno_t);
1350                         else
1351                                 nsize += NODEDSZ(node);
1352                         total += nsize;
1353                         nsize += sizeof(indx_t);
1354                         fprintf(stderr, "key %d: nsize %d, %s%s\n",
1355                                 i, nsize, DKEY(&key), mdb_leafnode_type(node));
1356                 }
1357                 total = EVEN(total);
1358         }
1359         fprintf(stderr, "Total: header %d + contents %d + unused %d\n",
1360                 IS_LEAF2(mp) ? PAGEHDRSZ : mp->mp_lower, total, SIZELEFT(mp));
1361 }
1362
1363 void
1364 mdb_cursor_chk(MDB_cursor *mc)
1365 {
1366         unsigned int i;
1367         MDB_node *node;
1368         MDB_page *mp;
1369
1370         if (!mc->mc_snum && !(mc->mc_flags & C_INITIALIZED)) return;
1371         for (i=0; i<mc->mc_top; i++) {
1372                 mp = mc->mc_pg[i];
1373                 node = NODEPTR(mp, mc->mc_ki[i]);
1374                 if (NODEPGNO(node) != mc->mc_pg[i+1]->mp_pgno)
1375                         printf("oops!\n");
1376         }
1377         if (mc->mc_ki[i] >= NUMKEYS(mc->mc_pg[i]))
1378                 printf("ack!\n");
1379 }
1380 #endif
1381
1382 #if (MDB_DEBUG) > 2
1383 /** Count all the pages in each DB and in the freelist
1384  *  and make sure it matches the actual number of pages
1385  *  being used.
1386  *  All named DBs must be open for a correct count.
1387  */
1388 static void mdb_audit(MDB_txn *txn)
1389 {
1390         MDB_cursor mc;
1391         MDB_val key, data;
1392         MDB_ID freecount, count;
1393         MDB_dbi i;
1394         int rc;
1395
1396         freecount = 0;
1397         mdb_cursor_init(&mc, txn, FREE_DBI, NULL);
1398         while ((rc = mdb_cursor_get(&mc, &key, &data, MDB_NEXT)) == 0)
1399                 freecount += *(MDB_ID *)data.mv_data;
1400         mdb_tassert(txn, rc == MDB_NOTFOUND);
1401
1402         count = 0;
1403         for (i = 0; i<txn->mt_numdbs; i++) {
1404                 MDB_xcursor mx;
1405                 if (!(txn->mt_dbflags[i] & DB_VALID))
1406                         continue;
1407                 mdb_cursor_init(&mc, txn, i, &mx);
1408                 if (txn->mt_dbs[i].md_root == P_INVALID)
1409                         continue;
1410                 count += txn->mt_dbs[i].md_branch_pages +
1411                         txn->mt_dbs[i].md_leaf_pages +
1412                         txn->mt_dbs[i].md_overflow_pages;
1413                 if (txn->mt_dbs[i].md_flags & MDB_DUPSORT) {
1414                         rc = mdb_page_search(&mc, NULL, MDB_PS_FIRST);
1415                         for (; rc == MDB_SUCCESS; rc = mdb_cursor_sibling(&mc, 1)) {
1416                                 unsigned j;
1417                                 MDB_page *mp;
1418                                 mp = mc.mc_pg[mc.mc_top];
1419                                 for (j=0; j<NUMKEYS(mp); j++) {
1420                                         MDB_node *leaf = NODEPTR(mp, j);
1421                                         if (leaf->mn_flags & F_SUBDATA) {
1422                                                 MDB_db db;
1423                                                 memcpy(&db, NODEDATA(leaf), sizeof(db));
1424                                                 count += db.md_branch_pages + db.md_leaf_pages +
1425                                                         db.md_overflow_pages;
1426                                         }
1427                                 }
1428                         }
1429                         mdb_tassert(txn, rc == MDB_NOTFOUND);
1430                 }
1431         }
1432         if (freecount + count + 2 /* metapages */ != txn->mt_next_pgno) {
1433                 fprintf(stderr, "audit: %lu freecount: %lu count: %lu total: %lu next_pgno: %lu\n",
1434                         txn->mt_txnid, freecount, count+2, freecount+count+2, txn->mt_next_pgno);
1435         }
1436 }
1437 #endif
1438
1439 int
1440 mdb_cmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)
1441 {
1442         return txn->mt_dbxs[dbi].md_cmp(a, b);
1443 }
1444
1445 int
1446 mdb_dcmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)
1447 {
1448         return txn->mt_dbxs[dbi].md_dcmp(a, b);
1449 }
1450
1451 /** Allocate memory for a page.
1452  * Re-use old malloc'd pages first for singletons, otherwise just malloc.
1453  */
1454 static MDB_page *
1455 mdb_page_malloc(MDB_txn *txn, unsigned num)
1456 {
1457         MDB_env *env = txn->mt_env;
1458         MDB_page *ret = env->me_dpages;
1459         size_t psize = env->me_psize, sz = psize, off;
1460         /* For ! #MDB_NOMEMINIT, psize counts how much to init.
1461          * For a single page alloc, we init everything after the page header.
1462          * For multi-page, we init the final page; if the caller needed that
1463          * many pages they will be filling in at least up to the last page.
1464          */
1465         if (num == 1) {
1466                 if (ret) {
1467                         VGMEMP_ALLOC(env, ret, sz);
1468                         VGMEMP_DEFINED(ret, sizeof(ret->mp_next));
1469                         env->me_dpages = ret->mp_next;
1470                         return ret;
1471                 }
1472                 psize -= off = PAGEHDRSZ;
1473         } else {
1474                 sz *= num;
1475                 off = sz - psize;
1476         }
1477         if ((ret = malloc(sz)) != NULL) {
1478                 VGMEMP_ALLOC(env, ret, sz);
1479                 if (!(env->me_flags & MDB_NOMEMINIT)) {
1480                         memset((char *)ret + off, 0, psize);
1481                         ret->mp_pad = 0;
1482                 }
1483         } else {
1484                 txn->mt_flags |= MDB_TXN_ERROR;
1485         }
1486         return ret;
1487 }
1488
1489 /** Free a single page.
1490  * Saves single pages to a list, for future reuse.
1491  * (This is not used for multi-page overflow pages.)
1492  */
1493 static void
1494 mdb_page_free(MDB_env *env, MDB_page *mp)
1495 {
1496         mp->mp_next = env->me_dpages;
1497         VGMEMP_FREE(env, mp);
1498         env->me_dpages = mp;
1499 }
1500
1501 /** Free a dirty page */
1502 static void
1503 mdb_dpage_free(MDB_env *env, MDB_page *dp)
1504 {
1505         if (!IS_OVERFLOW(dp) || dp->mp_pages == 1) {
1506                 mdb_page_free(env, dp);
1507         } else {
1508                 /* large pages just get freed directly */
1509                 VGMEMP_FREE(env, dp);
1510                 free(dp);
1511         }
1512 }
1513
1514 /**     Return all dirty pages to dpage list */
1515 static void
1516 mdb_dlist_free(MDB_txn *txn)
1517 {
1518         MDB_env *env = txn->mt_env;
1519         MDB_ID2L dl = txn->mt_u.dirty_list;
1520         unsigned i, n = dl[0].mid;
1521
1522         for (i = 1; i <= n; i++) {
1523                 mdb_dpage_free(env, dl[i].mptr);
1524         }
1525         dl[0].mid = 0;
1526 }
1527
1528 /** Set or clear P_KEEP in dirty, non-overflow, non-sub pages watched by txn.
1529  * @param[in] mc A cursor handle for the current operation.
1530  * @param[in] pflags Flags of the pages to update:
1531  * P_DIRTY to set P_KEEP, P_DIRTY|P_KEEP to clear it.
1532  * @param[in] all No shortcuts. Needed except after a full #mdb_page_flush().
1533  * @return 0 on success, non-zero on failure.
1534  */
1535 static int
1536 mdb_pages_xkeep(MDB_cursor *mc, unsigned pflags, int all)
1537 {
1538         enum { Mask = P_SUBP|P_DIRTY|P_KEEP };
1539         MDB_txn *txn = mc->mc_txn;
1540         MDB_cursor *m3;
1541         MDB_xcursor *mx;
1542         MDB_page *dp, *mp;
1543         MDB_node *leaf;
1544         unsigned i, j;
1545         int rc = MDB_SUCCESS, level;
1546
1547         /* Mark pages seen by cursors */
1548         if (mc->mc_flags & C_UNTRACK)
1549                 mc = NULL;                              /* will find mc in mt_cursors */
1550         for (i = txn->mt_numdbs;; mc = txn->mt_cursors[--i]) {
1551                 for (; mc; mc=mc->mc_next) {
1552                         if (!(mc->mc_flags & C_INITIALIZED))
1553                                 continue;
1554                         for (m3 = mc;; m3 = &mx->mx_cursor) {
1555                                 mp = NULL;
1556                                 for (j=0; j<m3->mc_snum; j++) {
1557                                         mp = m3->mc_pg[j];
1558                                         if ((mp->mp_flags & Mask) == pflags)
1559                                                 mp->mp_flags ^= P_KEEP;
1560                                 }
1561                                 mx = m3->mc_xcursor;
1562                                 /* Proceed to mx if it is at a sub-database */
1563                                 if (! (mx && (mx->mx_cursor.mc_flags & C_INITIALIZED)))
1564                                         break;
1565                                 if (! (mp && (mp->mp_flags & P_LEAF)))
1566                                         break;
1567                                 leaf = NODEPTR(mp, m3->mc_ki[j-1]);
1568                                 if (!(leaf->mn_flags & F_SUBDATA))
1569                                         break;
1570                         }
1571                 }
1572                 if (i == 0)
1573                         break;
1574         }
1575
1576         if (all) {
1577                 /* Mark dirty root pages */
1578                 for (i=0; i<txn->mt_numdbs; i++) {
1579                         if (txn->mt_dbflags[i] & DB_DIRTY) {
1580                                 pgno_t pgno = txn->mt_dbs[i].md_root;
1581                                 if (pgno == P_INVALID)
1582                                         continue;
1583                                 if ((rc = mdb_page_get(txn, pgno, &dp, &level)) != MDB_SUCCESS)
1584                                         break;
1585                                 if ((dp->mp_flags & Mask) == pflags && level <= 1)
1586                                         dp->mp_flags ^= P_KEEP;
1587                         }
1588                 }
1589         }
1590
1591         return rc;
1592 }
1593
1594 static int mdb_page_flush(MDB_txn *txn, int keep);
1595
1596 /**     Spill pages from the dirty list back to disk.
1597  * This is intended to prevent running into #MDB_TXN_FULL situations,
1598  * but note that they may still occur in a few cases:
1599  *      1) our estimate of the txn size could be too small. Currently this
1600  *       seems unlikely, except with a large number of #MDB_MULTIPLE items.
1601  *      2) child txns may run out of space if their parents dirtied a
1602  *       lot of pages and never spilled them. TODO: we probably should do
1603  *       a preemptive spill during #mdb_txn_begin() of a child txn, if
1604  *       the parent's dirty_room is below a given threshold.
1605  *
1606  * Otherwise, if not using nested txns, it is expected that apps will
1607  * not run into #MDB_TXN_FULL any more. The pages are flushed to disk
1608  * the same way as for a txn commit, e.g. their P_DIRTY flag is cleared.
1609  * If the txn never references them again, they can be left alone.
1610  * If the txn only reads them, they can be used without any fuss.
1611  * If the txn writes them again, they can be dirtied immediately without
1612  * going thru all of the work of #mdb_page_touch(). Such references are
1613  * handled by #mdb_page_unspill().
1614  *
1615  * Also note, we never spill DB root pages, nor pages of active cursors,
1616  * because we'll need these back again soon anyway. And in nested txns,
1617  * we can't spill a page in a child txn if it was already spilled in a
1618  * parent txn. That would alter the parent txns' data even though
1619  * the child hasn't committed yet, and we'd have no way to undo it if
1620  * the child aborted.
1621  *
1622  * @param[in] m0 cursor A cursor handle identifying the transaction and
1623  *      database for which we are checking space.
1624  * @param[in] key For a put operation, the key being stored.
1625  * @param[in] data For a put operation, the data being stored.
1626  * @return 0 on success, non-zero on failure.
1627  */
1628 static int
1629 mdb_page_spill(MDB_cursor *m0, MDB_val *key, MDB_val *data)
1630 {
1631         MDB_txn *txn = m0->mc_txn;
1632         MDB_page *dp;
1633         MDB_ID2L dl = txn->mt_u.dirty_list;
1634         unsigned int i, j, need;
1635         int rc;
1636
1637         if (m0->mc_flags & C_SUB)
1638                 return MDB_SUCCESS;
1639
1640         /* Estimate how much space this op will take */
1641         i = m0->mc_db->md_depth;
1642         /* Named DBs also dirty the main DB */
1643         if (m0->mc_dbi > MAIN_DBI)
1644                 i += txn->mt_dbs[MAIN_DBI].md_depth;
1645         /* For puts, roughly factor in the key+data size */
1646         if (key)
1647                 i += (LEAFSIZE(key, data) + txn->mt_env->me_psize) / txn->mt_env->me_psize;
1648         i += i; /* double it for good measure */
1649         need = i;
1650
1651         if (txn->mt_dirty_room > i)
1652                 return MDB_SUCCESS;
1653
1654         if (!txn->mt_spill_pgs) {
1655                 txn->mt_spill_pgs = mdb_midl_alloc(MDB_IDL_UM_MAX);
1656                 if (!txn->mt_spill_pgs)
1657                         return ENOMEM;
1658         } else {
1659                 /* purge deleted slots */
1660                 MDB_IDL sl = txn->mt_spill_pgs;
1661                 unsigned int num = sl[0];
1662                 j=0;
1663                 for (i=1; i<=num; i++) {
1664                         if (!(sl[i] & 1))
1665                                 sl[++j] = sl[i];
1666                 }
1667                 sl[0] = j;
1668         }
1669
1670         /* Preserve pages which may soon be dirtied again */
1671         if ((rc = mdb_pages_xkeep(m0, P_DIRTY, 1)) != MDB_SUCCESS)
1672                 goto done;
1673
1674         /* Less aggressive spill - we originally spilled the entire dirty list,
1675          * with a few exceptions for cursor pages and DB root pages. But this
1676          * turns out to be a lot of wasted effort because in a large txn many
1677          * of those pages will need to be used again. So now we spill only 1/8th
1678          * of the dirty pages. Testing revealed this to be a good tradeoff,
1679          * better than 1/2, 1/4, or 1/10.
1680          */
1681         if (need < MDB_IDL_UM_MAX / 8)
1682                 need = MDB_IDL_UM_MAX / 8;
1683
1684         /* Save the page IDs of all the pages we're flushing */
1685         /* flush from the tail forward, this saves a lot of shifting later on. */
1686         for (i=dl[0].mid; i && need; i--) {
1687                 MDB_ID pn = dl[i].mid << 1;
1688                 dp = dl[i].mptr;
1689                 if (dp->mp_flags & P_KEEP)
1690                         continue;
1691                 /* Can't spill twice, make sure it's not already in a parent's
1692                  * spill list.
1693                  */
1694                 if (txn->mt_parent) {
1695                         MDB_txn *tx2;
1696                         for (tx2 = txn->mt_parent; tx2; tx2 = tx2->mt_parent) {
1697                                 if (tx2->mt_spill_pgs) {
1698                                         j = mdb_midl_search(tx2->mt_spill_pgs, pn);
1699                                         if (j <= tx2->mt_spill_pgs[0] && tx2->mt_spill_pgs[j] == pn) {
1700                                                 dp->mp_flags |= P_KEEP;
1701                                                 break;
1702                                         }
1703                                 }
1704                         }
1705                         if (tx2)
1706                                 continue;
1707                 }
1708                 if ((rc = mdb_midl_append(&txn->mt_spill_pgs, pn)))
1709                         goto done;
1710                 need--;
1711         }
1712         mdb_midl_sort(txn->mt_spill_pgs);
1713
1714         /* Flush the spilled part of dirty list */
1715         if ((rc = mdb_page_flush(txn, i)) != MDB_SUCCESS)
1716                 goto done;
1717
1718         /* Reset any dirty pages we kept that page_flush didn't see */
1719         rc = mdb_pages_xkeep(m0, P_DIRTY|P_KEEP, i);
1720
1721 done:
1722         txn->mt_flags |= rc ? MDB_TXN_ERROR : MDB_TXN_SPILLS;
1723         return rc;
1724 }
1725
1726 /** Find oldest txnid still referenced. Expects txn->mt_txnid > 0. */
1727 static txnid_t
1728 mdb_find_oldest(MDB_txn *txn)
1729 {
1730         int i;
1731         txnid_t mr, oldest = txn->mt_txnid - 1;
1732         if (txn->mt_env->me_txns) {
1733                 MDB_reader *r = txn->mt_env->me_txns->mti_readers;
1734                 for (i = txn->mt_env->me_txns->mti_numreaders; --i >= 0; ) {
1735                         if (r[i].mr_pid) {
1736                                 mr = r[i].mr_txnid;
1737                                 if (oldest > mr)
1738                                         oldest = mr;
1739                         }
1740                 }
1741         }
1742         return oldest;
1743 }
1744
1745 /** Add a page to the txn's dirty list */
1746 static void
1747 mdb_page_dirty(MDB_txn *txn, MDB_page *mp)
1748 {
1749         MDB_ID2 mid;
1750         int rc, (*insert)(MDB_ID2L, MDB_ID2 *);
1751
1752         if (txn->mt_env->me_flags & MDB_WRITEMAP) {
1753                 insert = mdb_mid2l_append;
1754         } else {
1755                 insert = mdb_mid2l_insert;
1756         }
1757         mid.mid = mp->mp_pgno;
1758         mid.mptr = mp;
1759         rc = insert(txn->mt_u.dirty_list, &mid);
1760         mdb_tassert(txn, rc == 0);
1761         txn->mt_dirty_room--;
1762 }
1763
1764 /** Allocate page numbers and memory for writing.  Maintain me_pglast,
1765  * me_pghead and mt_next_pgno.
1766  *
1767  * If there are free pages available from older transactions, they
1768  * are re-used first. Otherwise allocate a new page at mt_next_pgno.
1769  * Do not modify the freedB, just merge freeDB records into me_pghead[]
1770  * and move me_pglast to say which records were consumed.  Only this
1771  * function can create me_pghead and move me_pglast/mt_next_pgno.
1772  * @param[in] mc cursor A cursor handle identifying the transaction and
1773  *      database for which we are allocating.
1774  * @param[in] num the number of pages to allocate.
1775  * @param[out] mp Address of the allocated page(s). Requests for multiple pages
1776  *  will always be satisfied by a single contiguous chunk of memory.
1777  * @return 0 on success, non-zero on failure.
1778  */
1779 static int
1780 mdb_page_alloc(MDB_cursor *mc, int num, MDB_page **mp)
1781 {
1782 #ifdef MDB_PARANOID     /* Seems like we can ignore this now */
1783         /* Get at most <Max_retries> more freeDB records once me_pghead
1784          * has enough pages.  If not enough, use new pages from the map.
1785          * If <Paranoid> and mc is updating the freeDB, only get new
1786          * records if me_pghead is empty. Then the freelist cannot play
1787          * catch-up with itself by growing while trying to save it.
1788          */
1789         enum { Paranoid = 1, Max_retries = 500 };
1790 #else
1791         enum { Paranoid = 0, Max_retries = INT_MAX /*infinite*/ };
1792 #endif
1793         int rc, retry = Max_retries;
1794         MDB_txn *txn = mc->mc_txn;
1795         MDB_env *env = txn->mt_env;
1796         pgno_t pgno, *mop = env->me_pghead;
1797         unsigned i, j, k, mop_len = mop ? mop[0] : 0, n2 = num-1;
1798         MDB_page *np;
1799         txnid_t oldest = 0, last;
1800         MDB_cursor_op op;
1801         MDB_cursor m2;
1802
1803         *mp = NULL;
1804
1805         /* If our dirty list is already full, we can't do anything */
1806         if (txn->mt_dirty_room == 0) {
1807                 rc = MDB_TXN_FULL;
1808                 goto fail;
1809         }
1810
1811         for (op = MDB_FIRST;; op = MDB_NEXT) {
1812                 MDB_val key, data;
1813                 MDB_node *leaf;
1814                 pgno_t *idl, old_id, new_id;
1815
1816                 /* Seek a big enough contiguous page range. Prefer
1817                  * pages at the tail, just truncating the list.
1818                  */
1819                 if (mop_len > n2) {
1820                         i = mop_len;
1821                         do {
1822                                 pgno = mop[i];
1823                                 if (mop[i-n2] == pgno+n2)
1824                                         goto search_done;
1825                         } while (--i > n2);
1826                         if (Max_retries < INT_MAX && --retry < 0)
1827                                 break;
1828                 }
1829
1830                 if (op == MDB_FIRST) {  /* 1st iteration */
1831                         /* Prepare to fetch more and coalesce */
1832                         oldest = mdb_find_oldest(txn);
1833                         last = env->me_pglast;
1834                         mdb_cursor_init(&m2, txn, FREE_DBI, NULL);
1835                         if (last) {
1836                                 op = MDB_SET_RANGE;
1837                                 key.mv_data = &last; /* will look up last+1 */
1838                                 key.mv_size = sizeof(last);
1839                         }
1840                         if (Paranoid && mc->mc_dbi == FREE_DBI)
1841                                 retry = -1;
1842                 }
1843                 if (Paranoid && retry < 0 && mop_len)
1844                         break;
1845
1846                 last++;
1847                 /* Do not fetch more if the record will be too recent */
1848                 if (oldest <= last)
1849                         break;
1850                 rc = mdb_cursor_get(&m2, &key, NULL, op);
1851                 if (rc) {
1852                         if (rc == MDB_NOTFOUND)
1853                                 break;
1854                         goto fail;
1855                 }
1856                 last = *(txnid_t*)key.mv_data;
1857                 if (oldest <= last)
1858                         break;
1859                 np = m2.mc_pg[m2.mc_top];
1860                 leaf = NODEPTR(np, m2.mc_ki[m2.mc_top]);
1861                 if ((rc = mdb_node_read(txn, leaf, &data)) != MDB_SUCCESS)
1862                         return rc;
1863
1864                 idl = (MDB_ID *) data.mv_data;
1865                 i = idl[0];
1866                 if (!mop) {
1867                         if (!(env->me_pghead = mop = mdb_midl_alloc(i))) {
1868                                 rc = ENOMEM;
1869                                 goto fail;
1870                         }
1871                 } else {
1872                         if ((rc = mdb_midl_need(&env->me_pghead, i)) != 0)
1873                                 goto fail;
1874                         mop = env->me_pghead;
1875                 }
1876                 env->me_pglast = last;
1877 #if (MDB_DEBUG) > 1
1878                 DPRINTF(("IDL read txn %"Z"u root %"Z"u num %u",
1879                         last, txn->mt_dbs[FREE_DBI].md_root, i));
1880                 for (k = i; k; k--)
1881                         DPRINTF(("IDL %"Z"u", idl[k]));
1882 #endif
1883                 /* Merge in descending sorted order */
1884                 j = mop_len;
1885                 k = mop_len += i;
1886                 mop[0] = (pgno_t)-1;
1887                 old_id = mop[j];
1888                 while (i) {
1889                         new_id = idl[i--];
1890                         for (; old_id < new_id; old_id = mop[--j])
1891                                 mop[k--] = old_id;
1892                         mop[k--] = new_id;
1893                 }
1894                 mop[0] = mop_len;
1895         }
1896
1897         /* Use new pages from the map when nothing suitable in the freeDB */
1898         i = 0;
1899         pgno = txn->mt_next_pgno;
1900         if (pgno + num >= env->me_maxpg) {
1901                         DPUTS("DB size maxed out");
1902                         rc = MDB_MAP_FULL;
1903                         goto fail;
1904         }
1905
1906 search_done:
1907         if (env->me_flags & MDB_WRITEMAP) {
1908                 np = (MDB_page *)(env->me_map + env->me_psize * pgno);
1909         } else {
1910                 if (!(np = mdb_page_malloc(txn, num))) {
1911                         rc = ENOMEM;
1912                         goto fail;
1913                 }
1914         }
1915         if (i) {
1916                 mop[0] = mop_len -= num;
1917                 /* Move any stragglers down */
1918                 for (j = i-num; j < mop_len; )
1919                         mop[++j] = mop[++i];
1920         } else {
1921                 txn->mt_next_pgno = pgno + num;
1922         }
1923         np->mp_pgno = pgno;
1924         mdb_page_dirty(txn, np);
1925         *mp = np;
1926
1927         return MDB_SUCCESS;
1928
1929 fail:
1930         txn->mt_flags |= MDB_TXN_ERROR;
1931         return rc;
1932 }
1933
1934 /** Copy the used portions of a non-overflow page.
1935  * @param[in] dst page to copy into
1936  * @param[in] src page to copy from
1937  * @param[in] psize size of a page
1938  */
1939 static void
1940 mdb_page_copy(MDB_page *dst, MDB_page *src, unsigned int psize)
1941 {
1942         enum { Align = sizeof(pgno_t) };
1943         indx_t upper = src->mp_upper, lower = src->mp_lower, unused = upper-lower;
1944
1945         /* If page isn't full, just copy the used portion. Adjust
1946          * alignment so memcpy may copy words instead of bytes.
1947          */
1948         if ((unused &= -Align) && !IS_LEAF2(src)) {
1949                 upper &= -Align;
1950                 memcpy(dst, src, (lower + (Align-1)) & -Align);
1951                 memcpy((pgno_t *)((char *)dst+upper), (pgno_t *)((char *)src+upper),
1952                         psize - upper);
1953         } else {
1954                 memcpy(dst, src, psize - unused);
1955         }
1956 }
1957
1958 /** Pull a page off the txn's spill list, if present.
1959  * If a page being referenced was spilled to disk in this txn, bring
1960  * it back and make it dirty/writable again.
1961  * @param[in] txn the transaction handle.
1962  * @param[in] mp the page being referenced. It must not be dirty.
1963  * @param[out] ret the writable page, if any. ret is unchanged if
1964  * mp wasn't spilled.
1965  */
1966 static int
1967 mdb_page_unspill(MDB_txn *txn, MDB_page *mp, MDB_page **ret)
1968 {
1969         MDB_env *env = txn->mt_env;
1970         const MDB_txn *tx2;
1971         unsigned x;
1972         pgno_t pgno = mp->mp_pgno, pn = pgno << 1;
1973
1974         for (tx2 = txn; tx2; tx2=tx2->mt_parent) {
1975                 if (!tx2->mt_spill_pgs)
1976                         continue;
1977                 x = mdb_midl_search(tx2->mt_spill_pgs, pn);
1978                 if (x <= tx2->mt_spill_pgs[0] && tx2->mt_spill_pgs[x] == pn) {
1979                         MDB_page *np;
1980                         int num;
1981                         if (txn->mt_dirty_room == 0)
1982                                 return MDB_TXN_FULL;
1983                         if (IS_OVERFLOW(mp))
1984                                 num = mp->mp_pages;
1985                         else
1986                                 num = 1;
1987                         if (env->me_flags & MDB_WRITEMAP) {
1988                                 np = mp;
1989                         } else {
1990                                 np = mdb_page_malloc(txn, num);
1991                                 if (!np)
1992                                         return ENOMEM;
1993                                 if (num > 1)
1994                                         memcpy(np, mp, num * env->me_psize);
1995                                 else
1996                                         mdb_page_copy(np, mp, env->me_psize);
1997                         }
1998                         if (tx2 == txn) {
1999                                 /* If in current txn, this page is no longer spilled.
2000                                  * If it happens to be the last page, truncate the spill list.
2001                                  * Otherwise mark it as deleted by setting the LSB.
2002                                  */
2003                                 if (x == txn->mt_spill_pgs[0])
2004                                         txn->mt_spill_pgs[0]--;
2005                                 else
2006                                         txn->mt_spill_pgs[x] |= 1;
2007                         }       /* otherwise, if belonging to a parent txn, the
2008                                  * page remains spilled until child commits
2009                                  */
2010
2011                         mdb_page_dirty(txn, np);
2012                         np->mp_flags |= P_DIRTY;
2013                         *ret = np;
2014                         break;
2015                 }
2016         }
2017         return MDB_SUCCESS;
2018 }
2019
2020 /** Touch a page: make it dirty and re-insert into tree with updated pgno.
2021  * @param[in] mc cursor pointing to the page to be touched
2022  * @return 0 on success, non-zero on failure.
2023  */
2024 static int
2025 mdb_page_touch(MDB_cursor *mc)
2026 {
2027         MDB_page *mp = mc->mc_pg[mc->mc_top], *np;
2028         MDB_txn *txn = mc->mc_txn;
2029         MDB_cursor *m2, *m3;
2030         pgno_t  pgno;
2031         int rc;
2032
2033         if (!F_ISSET(mp->mp_flags, P_DIRTY)) {
2034                 if (txn->mt_flags & MDB_TXN_SPILLS) {
2035                         np = NULL;
2036                         rc = mdb_page_unspill(txn, mp, &np);
2037                         if (rc)
2038                                 goto fail;
2039                         if (np)
2040                                 goto done;
2041                 }
2042                 if ((rc = mdb_midl_need(&txn->mt_free_pgs, 1)) ||
2043                         (rc = mdb_page_alloc(mc, 1, &np)))
2044                         goto fail;
2045                 pgno = np->mp_pgno;
2046                 DPRINTF(("touched db %d page %"Z"u -> %"Z"u", DDBI(mc),
2047                         mp->mp_pgno, pgno));
2048                 mdb_cassert(mc, mp->mp_pgno != pgno);
2049                 mdb_midl_xappend(txn->mt_free_pgs, mp->mp_pgno);
2050                 /* Update the parent page, if any, to point to the new page */
2051                 if (mc->mc_top) {
2052                         MDB_page *parent = mc->mc_pg[mc->mc_top-1];
2053                         MDB_node *node = NODEPTR(parent, mc->mc_ki[mc->mc_top-1]);
2054                         SETPGNO(node, pgno);
2055                 } else {
2056                         mc->mc_db->md_root = pgno;
2057                 }
2058         } else if (txn->mt_parent && !IS_SUBP(mp)) {
2059                 MDB_ID2 mid, *dl = txn->mt_u.dirty_list;
2060                 pgno = mp->mp_pgno;
2061                 /* If txn has a parent, make sure the page is in our
2062                  * dirty list.
2063                  */
2064                 if (dl[0].mid) {
2065                         unsigned x = mdb_mid2l_search(dl, pgno);
2066                         if (x <= dl[0].mid && dl[x].mid == pgno) {
2067                                 if (mp != dl[x].mptr) { /* bad cursor? */
2068                                         mc->mc_flags &= ~(C_INITIALIZED|C_EOF);
2069                                         txn->mt_flags |= MDB_TXN_ERROR;
2070                                         return MDB_CORRUPTED;
2071                                 }
2072                                 return 0;
2073                         }
2074                 }
2075                 mdb_cassert(mc, dl[0].mid < MDB_IDL_UM_MAX);
2076                 /* No - copy it */
2077                 np = mdb_page_malloc(txn, 1);
2078                 if (!np)
2079                         return ENOMEM;
2080                 mid.mid = pgno;
2081                 mid.mptr = np;
2082                 rc = mdb_mid2l_insert(dl, &mid);
2083                 mdb_cassert(mc, rc == 0);
2084         } else {
2085                 return 0;
2086         }
2087
2088         mdb_page_copy(np, mp, txn->mt_env->me_psize);
2089         np->mp_pgno = pgno;
2090         np->mp_flags |= P_DIRTY;
2091
2092 done:
2093         /* Adjust cursors pointing to mp */
2094         mc->mc_pg[mc->mc_top] = np;
2095         m2 = txn->mt_cursors[mc->mc_dbi];
2096         if (mc->mc_flags & C_SUB) {
2097                 for (; m2; m2=m2->mc_next) {
2098                         m3 = &m2->mc_xcursor->mx_cursor;
2099                         if (m3->mc_snum < mc->mc_snum) continue;
2100                         if (m3->mc_pg[mc->mc_top] == mp)
2101                                 m3->mc_pg[mc->mc_top] = np;
2102                 }
2103         } else {
2104                 for (; m2; m2=m2->mc_next) {
2105                         if (m2->mc_snum < mc->mc_snum) continue;
2106                         if (m2->mc_pg[mc->mc_top] == mp) {
2107                                 m2->mc_pg[mc->mc_top] = np;
2108                                 if ((mc->mc_db->md_flags & MDB_DUPSORT) &&
2109                                         IS_LEAF(np) &&
2110                                         m2->mc_ki[mc->mc_top] == mc->mc_ki[mc->mc_top])
2111                                 {
2112                                         MDB_node *leaf = NODEPTR(np, mc->mc_ki[mc->mc_top]);
2113                                         if (!(leaf->mn_flags & F_SUBDATA))
2114                                                 m2->mc_xcursor->mx_cursor.mc_pg[0] = NODEDATA(leaf);
2115                                 }
2116                         }
2117                 }
2118         }
2119         return 0;
2120
2121 fail:
2122         txn->mt_flags |= MDB_TXN_ERROR;
2123         return rc;
2124 }
2125
2126 int
2127 mdb_env_sync(MDB_env *env, int force)
2128 {
2129         int rc = 0;
2130         if (force || !F_ISSET(env->me_flags, MDB_NOSYNC)) {
2131                 if (env->me_flags & MDB_WRITEMAP) {
2132                         int flags = ((env->me_flags & MDB_MAPASYNC) && !force)
2133                                 ? MS_ASYNC : MS_SYNC;
2134                         if (MDB_MSYNC(env->me_map, env->me_mapsize, flags))
2135                                 rc = ErrCode();
2136 #ifdef _WIN32
2137                         else if (flags == MS_SYNC && MDB_FDATASYNC(env->me_fd))
2138                                 rc = ErrCode();
2139 #endif
2140                 } else {
2141                         if (MDB_FDATASYNC(env->me_fd))
2142                                 rc = ErrCode();
2143                 }
2144         }
2145         return rc;
2146 }
2147
2148 /** Back up parent txn's cursors, then grab the originals for tracking */
2149 static int
2150 mdb_cursor_shadow(MDB_txn *src, MDB_txn *dst)
2151 {
2152         MDB_cursor *mc, *bk;
2153         MDB_xcursor *mx;
2154         size_t size;
2155         int i;
2156
2157         for (i = src->mt_numdbs; --i >= 0; ) {
2158                 if ((mc = src->mt_cursors[i]) != NULL) {
2159                         size = sizeof(MDB_cursor);
2160                         if (mc->mc_xcursor)
2161                                 size += sizeof(MDB_xcursor);
2162                         for (; mc; mc = bk->mc_next) {
2163                                 bk = malloc(size);
2164                                 if (!bk)
2165                                         return ENOMEM;
2166                                 *bk = *mc;
2167                                 mc->mc_backup = bk;
2168                                 mc->mc_db = &dst->mt_dbs[i];
2169                                 /* Kill pointers into src - and dst to reduce abuse: The
2170                                  * user may not use mc until dst ends. Otherwise we'd...
2171                                  */
2172                                 mc->mc_txn    = NULL;   /* ...set this to dst */
2173                                 mc->mc_dbflag = NULL;   /* ...and &dst->mt_dbflags[i] */
2174                                 if ((mx = mc->mc_xcursor) != NULL) {
2175                                         *(MDB_xcursor *)(bk+1) = *mx;
2176                                         mx->mx_cursor.mc_txn = NULL; /* ...and dst. */
2177                                 }
2178                                 mc->mc_next = dst->mt_cursors[i];
2179                                 dst->mt_cursors[i] = mc;
2180                         }
2181                 }
2182         }
2183         return MDB_SUCCESS;
2184 }
2185
2186 /** Close this write txn's cursors, give parent txn's cursors back to parent.
2187  * @param[in] txn the transaction handle.
2188  * @param[in] merge true to keep changes to parent cursors, false to revert.
2189  * @return 0 on success, non-zero on failure.
2190  */
2191 static void
2192 mdb_cursors_close(MDB_txn *txn, unsigned merge)
2193 {
2194         MDB_cursor **cursors = txn->mt_cursors, *mc, *next, *bk;
2195         MDB_xcursor *mx;
2196         int i;
2197
2198         for (i = txn->mt_numdbs; --i >= 0; ) {
2199                 for (mc = cursors[i]; mc; mc = next) {
2200                         next = mc->mc_next;
2201                         if ((bk = mc->mc_backup) != NULL) {
2202                                 if (merge) {
2203                                         /* Commit changes to parent txn */
2204                                         mc->mc_next = bk->mc_next;
2205                                         mc->mc_backup = bk->mc_backup;
2206                                         mc->mc_txn = bk->mc_txn;
2207                                         mc->mc_db = bk->mc_db;
2208                                         mc->mc_dbflag = bk->mc_dbflag;
2209                                         if ((mx = mc->mc_xcursor) != NULL)
2210                                                 mx->mx_cursor.mc_txn = bk->mc_txn;
2211                                 } else {
2212                                         /* Abort nested txn */
2213                                         *mc = *bk;
2214                                         if ((mx = mc->mc_xcursor) != NULL)
2215                                                 *mx = *(MDB_xcursor *)(bk+1);
2216                                 }
2217                                 mc = bk;
2218                         }
2219                         /* Only malloced cursors are permanently tracked. */
2220                         free(mc);
2221                 }
2222                 cursors[i] = NULL;
2223         }
2224 }
2225
2226 #if !(MDB_DEBUG)
2227 #define mdb_txn_reset0(txn, act) mdb_txn_reset0(txn)
2228 #endif
2229 static void
2230 mdb_txn_reset0(MDB_txn *txn, const char *act);
2231
2232 #if !(MDB_PIDLOCK)              /* Currently the same as defined(_WIN32) */
2233 enum Pidlock_op {
2234         Pidset, Pidcheck
2235 };
2236 #else
2237 enum Pidlock_op {
2238         Pidset = F_SETLK, Pidcheck = F_GETLK
2239 };
2240 #endif
2241
2242 /** Set or check a pid lock. Set returns 0 on success.
2243  * Check returns 0 if the process is certainly dead, nonzero if it may
2244  * be alive (the lock exists or an error happened so we do not know).
2245  *
2246  * On Windows Pidset is a no-op, we merely check for the existence
2247  * of the process with the given pid. On POSIX we use a single byte
2248  * lock on the lockfile, set at an offset equal to the pid.
2249  */
2250 static int
2251 mdb_reader_pid(MDB_env *env, enum Pidlock_op op, MDB_PID_T pid)
2252 {
2253 #if !(MDB_PIDLOCK)              /* Currently the same as defined(_WIN32) */
2254         int ret = 0;
2255         HANDLE h;
2256         if (op == Pidcheck) {
2257                 h = OpenProcess(env->me_pidquery, FALSE, pid);
2258                 /* No documented "no such process" code, but other program use this: */
2259                 if (!h)
2260                         return ErrCode() != ERROR_INVALID_PARAMETER;
2261                 /* A process exists until all handles to it close. Has it exited? */
2262                 ret = WaitForSingleObject(h, 0) != 0;
2263                 CloseHandle(h);
2264         }
2265         return ret;
2266 #else
2267         for (;;) {
2268                 int rc;
2269                 struct flock lock_info;
2270                 memset(&lock_info, 0, sizeof(lock_info));
2271                 lock_info.l_type = F_WRLCK;
2272                 lock_info.l_whence = SEEK_SET;
2273                 lock_info.l_start = pid;
2274                 lock_info.l_len = 1;
2275                 if ((rc = fcntl(env->me_lfd, op, &lock_info)) == 0) {
2276                         if (op == F_GETLK && lock_info.l_type != F_UNLCK)
2277                                 rc = -1;
2278                 } else if ((rc = ErrCode()) == EINTR) {
2279                         continue;
2280                 }
2281                 return rc;
2282         }
2283 #endif
2284 }
2285
2286 /** Common code for #mdb_txn_begin() and #mdb_txn_renew().
2287  * @param[in] txn the transaction handle to initialize
2288  * @return 0 on success, non-zero on failure.
2289  */
2290 static int
2291 mdb_txn_renew0(MDB_txn *txn)
2292 {
2293         MDB_env *env = txn->mt_env;
2294         MDB_txninfo *ti = env->me_txns;
2295         MDB_meta *meta;
2296         unsigned int i, nr;
2297         uint16_t x;
2298         int rc, new_notls = 0;
2299
2300         /* Setup db info */
2301         txn->mt_numdbs = env->me_numdbs;
2302         txn->mt_dbxs = env->me_dbxs;    /* mostly static anyway */
2303
2304         if (txn->mt_flags & MDB_TXN_RDONLY) {
2305                 if (!ti) {
2306                         meta = env->me_metas[ mdb_env_pick_meta(env) ];
2307                         txn->mt_txnid = meta->mm_txnid;
2308                         txn->mt_u.reader = NULL;
2309                 } else {
2310                         MDB_reader *r = (env->me_flags & MDB_NOTLS) ? txn->mt_u.reader :
2311                                 pthread_getspecific(env->me_txkey);
2312                         if (r) {
2313                                 if (r->mr_pid != env->me_pid || r->mr_txnid != (txnid_t)-1)
2314                                         return MDB_BAD_RSLOT;
2315                         } else {
2316                                 MDB_PID_T pid = env->me_pid;
2317                                 pthread_t tid = pthread_self();
2318
2319                                 if (!env->me_live_reader) {
2320                                         rc = mdb_reader_pid(env, Pidset, pid);
2321                                         if (rc)
2322                                                 return rc;
2323                                         env->me_live_reader = 1;
2324                                 }
2325
2326                                 LOCK_MUTEX_R(env);
2327                                 nr = ti->mti_numreaders;
2328                                 for (i=0; i<nr; i++)
2329                                         if (ti->mti_readers[i].mr_pid == 0)
2330                                                 break;
2331                                 if (i == env->me_maxreaders) {
2332                                         UNLOCK_MUTEX_R(env);
2333                                         return MDB_READERS_FULL;
2334                                 }
2335                                 ti->mti_readers[i].mr_pid = pid;
2336                                 ti->mti_readers[i].mr_tid = tid;
2337                                 if (i == nr)
2338                                         ti->mti_numreaders = ++nr;
2339                                 /* Save numreaders for un-mutexed mdb_env_close() */
2340                                 env->me_numreaders = nr;
2341                                 UNLOCK_MUTEX_R(env);
2342
2343                                 r = &ti->mti_readers[i];
2344                                 new_notls = (env->me_flags & MDB_NOTLS);
2345                                 if (!new_notls && (rc=pthread_setspecific(env->me_txkey, r))) {
2346                                         r->mr_pid = 0;
2347                                         return rc;
2348                                 }
2349                         }
2350                         txn->mt_txnid = r->mr_txnid = ti->mti_txnid;
2351                         txn->mt_u.reader = r;
2352                         meta = env->me_metas[txn->mt_txnid & 1];
2353                 }
2354         } else {
2355                 if (ti) {
2356                         LOCK_MUTEX_W(env);
2357
2358                         txn->mt_txnid = ti->mti_txnid;
2359                         meta = env->me_metas[txn->mt_txnid & 1];
2360                 } else {
2361                         meta = env->me_metas[ mdb_env_pick_meta(env) ];
2362                         txn->mt_txnid = meta->mm_txnid;
2363                 }
2364                 txn->mt_txnid++;
2365 #if MDB_DEBUG
2366                 if (txn->mt_txnid == mdb_debug_start)
2367                         mdb_debug = 1;
2368 #endif
2369                 txn->mt_dirty_room = MDB_IDL_UM_MAX;
2370                 txn->mt_u.dirty_list = env->me_dirty_list;
2371                 txn->mt_u.dirty_list[0].mid = 0;
2372                 txn->mt_free_pgs = env->me_free_pgs;
2373                 txn->mt_free_pgs[0] = 0;
2374                 txn->mt_spill_pgs = NULL;
2375                 env->me_txn = txn;
2376         }
2377
2378         /* Copy the DB info and flags */
2379         memcpy(txn->mt_dbs, meta->mm_dbs, 2 * sizeof(MDB_db));
2380
2381         /* Moved to here to avoid a data race in read TXNs */
2382         txn->mt_next_pgno = meta->mm_last_pg+1;
2383
2384         for (i=2; i<txn->mt_numdbs; i++) {
2385                 x = env->me_dbflags[i];
2386                 txn->mt_dbs[i].md_flags = x & PERSISTENT_FLAGS;
2387                 txn->mt_dbflags[i] = (x & MDB_VALID) ? DB_VALID|DB_STALE : 0;
2388         }
2389         txn->mt_dbflags[0] = txn->mt_dbflags[1] = DB_VALID;
2390
2391         if (env->me_maxpg < txn->mt_next_pgno) {
2392                 mdb_txn_reset0(txn, "renew0-mapfail");
2393                 if (new_notls) {
2394                         txn->mt_u.reader->mr_pid = 0;
2395                         txn->mt_u.reader = NULL;
2396                 }
2397                 return MDB_MAP_RESIZED;
2398         }
2399
2400         return MDB_SUCCESS;
2401 }
2402
2403 int
2404 mdb_txn_renew(MDB_txn *txn)
2405 {
2406         int rc;
2407
2408         if (!txn || txn->mt_dbxs)       /* A reset txn has mt_dbxs==NULL */
2409                 return EINVAL;
2410
2411         if (txn->mt_env->me_flags & MDB_FATAL_ERROR) {
2412                 DPUTS("environment had fatal error, must shutdown!");
2413                 return MDB_PANIC;
2414         }
2415
2416         rc = mdb_txn_renew0(txn);
2417         if (rc == MDB_SUCCESS) {
2418                 DPRINTF(("renew txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
2419                         txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',
2420                         (void *)txn, (void *)txn->mt_env, txn->mt_dbs[MAIN_DBI].md_root));
2421         }
2422         return rc;
2423 }
2424
2425 int
2426 mdb_txn_begin(MDB_env *env, MDB_txn *parent, unsigned int flags, MDB_txn **ret)
2427 {
2428         MDB_txn *txn;
2429         MDB_ntxn *ntxn;
2430         int rc, size, tsize = sizeof(MDB_txn);
2431
2432         if (env->me_flags & MDB_FATAL_ERROR) {
2433                 DPUTS("environment had fatal error, must shutdown!");
2434                 return MDB_PANIC;
2435         }
2436         if ((env->me_flags & MDB_RDONLY) && !(flags & MDB_RDONLY))
2437                 return EACCES;
2438         if (parent) {
2439                 /* Nested transactions: Max 1 child, write txns only, no writemap */
2440                 if (parent->mt_child ||
2441                         (flags & MDB_RDONLY) ||
2442                         (parent->mt_flags & (MDB_TXN_RDONLY|MDB_TXN_ERROR)) ||
2443                         (env->me_flags & MDB_WRITEMAP))
2444                 {
2445                         return (parent->mt_flags & MDB_TXN_RDONLY) ? EINVAL : MDB_BAD_TXN;
2446                 }
2447                 tsize = sizeof(MDB_ntxn);
2448         }
2449         size = tsize + env->me_maxdbs * (sizeof(MDB_db)+1);
2450         if (!(flags & MDB_RDONLY))
2451                 size += env->me_maxdbs * sizeof(MDB_cursor *);
2452
2453         if ((txn = calloc(1, size)) == NULL) {
2454                 DPRINTF(("calloc: %s", strerror(ErrCode())));
2455                 return ENOMEM;
2456         }
2457         txn->mt_dbs = (MDB_db *) ((char *)txn + tsize);
2458         if (flags & MDB_RDONLY) {
2459                 txn->mt_flags |= MDB_TXN_RDONLY;
2460                 txn->mt_dbflags = (unsigned char *)(txn->mt_dbs + env->me_maxdbs);
2461         } else {
2462                 txn->mt_cursors = (MDB_cursor **)(txn->mt_dbs + env->me_maxdbs);
2463                 txn->mt_dbflags = (unsigned char *)(txn->mt_cursors + env->me_maxdbs);
2464         }
2465         txn->mt_env = env;
2466
2467         if (parent) {
2468                 unsigned int i;
2469                 txn->mt_u.dirty_list = malloc(sizeof(MDB_ID2)*MDB_IDL_UM_SIZE);
2470                 if (!txn->mt_u.dirty_list ||
2471                         !(txn->mt_free_pgs = mdb_midl_alloc(MDB_IDL_UM_MAX)))
2472                 {
2473                         free(txn->mt_u.dirty_list);
2474                         free(txn);
2475                         return ENOMEM;
2476                 }
2477                 txn->mt_txnid = parent->mt_txnid;
2478                 txn->mt_dirty_room = parent->mt_dirty_room;
2479                 txn->mt_u.dirty_list[0].mid = 0;
2480                 txn->mt_spill_pgs = NULL;
2481                 txn->mt_next_pgno = parent->mt_next_pgno;
2482                 parent->mt_child = txn;
2483                 txn->mt_parent = parent;
2484                 txn->mt_numdbs = parent->mt_numdbs;
2485                 txn->mt_flags = parent->mt_flags;
2486                 txn->mt_dbxs = parent->mt_dbxs;
2487                 memcpy(txn->mt_dbs, parent->mt_dbs, txn->mt_numdbs * sizeof(MDB_db));
2488                 /* Copy parent's mt_dbflags, but clear DB_NEW */
2489                 for (i=0; i<txn->mt_numdbs; i++)
2490                         txn->mt_dbflags[i] = parent->mt_dbflags[i] & ~DB_NEW;
2491                 rc = 0;
2492                 ntxn = (MDB_ntxn *)txn;
2493                 ntxn->mnt_pgstate = env->me_pgstate; /* save parent me_pghead & co */
2494                 if (env->me_pghead) {
2495                         size = MDB_IDL_SIZEOF(env->me_pghead);
2496                         env->me_pghead = mdb_midl_alloc(env->me_pghead[0]);
2497                         if (env->me_pghead)
2498                                 memcpy(env->me_pghead, ntxn->mnt_pgstate.mf_pghead, size);
2499                         else
2500                                 rc = ENOMEM;
2501                 }
2502                 if (!rc)
2503                         rc = mdb_cursor_shadow(parent, txn);
2504                 if (rc)
2505                         mdb_txn_reset0(txn, "beginchild-fail");
2506         } else {
2507                 rc = mdb_txn_renew0(txn);
2508         }
2509         if (rc)
2510                 free(txn);
2511         else {
2512                 *ret = txn;
2513                 DPRINTF(("begin txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
2514                         txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',
2515                         (void *) txn, (void *) env, txn->mt_dbs[MAIN_DBI].md_root));
2516         }
2517
2518         return rc;
2519 }
2520
2521 MDB_env *
2522 mdb_txn_env(MDB_txn *txn)
2523 {
2524         if(!txn) return NULL;
2525         return txn->mt_env;
2526 }
2527
2528 /** Export or close DBI handles opened in this txn. */
2529 static void
2530 mdb_dbis_update(MDB_txn *txn, int keep)
2531 {
2532         int i;
2533         MDB_dbi n = txn->mt_numdbs;
2534         MDB_env *env = txn->mt_env;
2535         unsigned char *tdbflags = txn->mt_dbflags;
2536
2537         for (i = n; --i >= 2;) {
2538                 if (tdbflags[i] & DB_NEW) {
2539                         if (keep) {
2540                                 env->me_dbflags[i] = txn->mt_dbs[i].md_flags | MDB_VALID;
2541                         } else {
2542                                 char *ptr = env->me_dbxs[i].md_name.mv_data;
2543                                 env->me_dbxs[i].md_name.mv_data = NULL;
2544                                 env->me_dbxs[i].md_name.mv_size = 0;
2545                                 env->me_dbflags[i] = 0;
2546                                 free(ptr);
2547                         }
2548                 }
2549         }
2550         if (keep && env->me_numdbs < n)
2551                 env->me_numdbs = n;
2552 }
2553
2554 /** Common code for #mdb_txn_reset() and #mdb_txn_abort().
2555  * May be called twice for readonly txns: First reset it, then abort.
2556  * @param[in] txn the transaction handle to reset
2557  * @param[in] act why the transaction is being reset
2558  */
2559 static void
2560 mdb_txn_reset0(MDB_txn *txn, const char *act)
2561 {
2562         MDB_env *env = txn->mt_env;
2563
2564         /* Close any DBI handles opened in this txn */
2565         mdb_dbis_update(txn, 0);
2566
2567         DPRINTF(("%s txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
2568                 act, txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',
2569                 (void *) txn, (void *)env, txn->mt_dbs[MAIN_DBI].md_root));
2570
2571         if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY)) {
2572                 if (txn->mt_u.reader) {
2573                         txn->mt_u.reader->mr_txnid = (txnid_t)-1;
2574                         if (!(env->me_flags & MDB_NOTLS))
2575                                 txn->mt_u.reader = NULL; /* txn does not own reader */
2576                 }
2577                 txn->mt_numdbs = 0;             /* close nothing if called again */
2578                 txn->mt_dbxs = NULL;    /* mark txn as reset */
2579         } else {
2580                 mdb_cursors_close(txn, 0);
2581
2582                 if (!(env->me_flags & MDB_WRITEMAP)) {
2583                         mdb_dlist_free(txn);
2584                 }
2585                 mdb_midl_free(env->me_pghead);
2586
2587                 if (txn->mt_parent) {
2588                         txn->mt_parent->mt_child = NULL;
2589                         env->me_pgstate = ((MDB_ntxn *)txn)->mnt_pgstate;
2590                         mdb_midl_free(txn->mt_free_pgs);
2591                         mdb_midl_free(txn->mt_spill_pgs);
2592                         free(txn->mt_u.dirty_list);
2593                         return;
2594                 }
2595
2596                 if (mdb_midl_shrink(&txn->mt_free_pgs))
2597                         env->me_free_pgs = txn->mt_free_pgs;
2598                 env->me_pghead = NULL;
2599                 env->me_pglast = 0;
2600
2601                 env->me_txn = NULL;
2602                 /* The writer mutex was locked in mdb_txn_begin. */
2603                 if (env->me_txns)
2604                         UNLOCK_MUTEX_W(env);
2605         }
2606 }
2607
2608 void
2609 mdb_txn_reset(MDB_txn *txn)
2610 {
2611         if (txn == NULL)
2612                 return;
2613
2614         /* This call is only valid for read-only txns */
2615         if (!(txn->mt_flags & MDB_TXN_RDONLY))
2616                 return;
2617
2618         mdb_txn_reset0(txn, "reset");
2619 }
2620
2621 void
2622 mdb_txn_abort(MDB_txn *txn)
2623 {
2624         if (txn == NULL)
2625                 return;
2626
2627         if (txn->mt_child)
2628                 mdb_txn_abort(txn->mt_child);
2629
2630         mdb_txn_reset0(txn, "abort");
2631         /* Free reader slot tied to this txn (if MDB_NOTLS && writable FS) */
2632         if ((txn->mt_flags & MDB_TXN_RDONLY) && txn->mt_u.reader)
2633                 txn->mt_u.reader->mr_pid = 0;
2634
2635         free(txn);
2636 }
2637
2638 /** Save the freelist as of this transaction to the freeDB.
2639  * This changes the freelist. Keep trying until it stabilizes.
2640  */
2641 static int
2642 mdb_freelist_save(MDB_txn *txn)
2643 {
2644         /* env->me_pghead[] can grow and shrink during this call.
2645          * env->me_pglast and txn->mt_free_pgs[] can only grow.
2646          * Page numbers cannot disappear from txn->mt_free_pgs[].
2647          */
2648         MDB_cursor mc;
2649         MDB_env *env = txn->mt_env;
2650         int rc, maxfree_1pg = env->me_maxfree_1pg, more = 1;
2651         txnid_t pglast = 0, head_id = 0;
2652         pgno_t  freecnt = 0, *free_pgs, *mop;
2653         ssize_t head_room = 0, total_room = 0, mop_len, clean_limit;
2654
2655         mdb_cursor_init(&mc, txn, FREE_DBI, NULL);
2656
2657         if (env->me_pghead) {
2658                 /* Make sure first page of freeDB is touched and on freelist */
2659                 rc = mdb_page_search(&mc, NULL, MDB_PS_FIRST|MDB_PS_MODIFY);
2660                 if (rc && rc != MDB_NOTFOUND)
2661                         return rc;
2662         }
2663
2664         /* MDB_RESERVE cancels meminit in ovpage malloc (when no WRITEMAP) */
2665         clean_limit = (env->me_flags & (MDB_NOMEMINIT|MDB_WRITEMAP))
2666                 ? SSIZE_MAX : maxfree_1pg;
2667
2668         for (;;) {
2669                 /* Come back here after each Put() in case freelist changed */
2670                 MDB_val key, data;
2671                 pgno_t *pgs;
2672                 ssize_t j;
2673
2674                 /* If using records from freeDB which we have not yet
2675                  * deleted, delete them and any we reserved for me_pghead.
2676                  */
2677                 while (pglast < env->me_pglast) {
2678                         rc = mdb_cursor_first(&mc, &key, NULL);
2679                         if (rc)
2680                                 return rc;
2681                         pglast = head_id = *(txnid_t *)key.mv_data;
2682                         total_room = head_room = 0;
2683                         mdb_tassert(txn, pglast <= env->me_pglast);
2684                         rc = mdb_cursor_del(&mc, 0);
2685                         if (rc)
2686                                 return rc;
2687                 }
2688
2689                 /* Save the IDL of pages freed by this txn, to a single record */
2690                 if (freecnt < txn->mt_free_pgs[0]) {
2691                         if (!freecnt) {
2692                                 /* Make sure last page of freeDB is touched and on freelist */
2693                                 rc = mdb_page_search(&mc, NULL, MDB_PS_LAST|MDB_PS_MODIFY);
2694                                 if (rc && rc != MDB_NOTFOUND)
2695                                         return rc;
2696                         }
2697                         free_pgs = txn->mt_free_pgs;
2698                         /* Write to last page of freeDB */
2699                         key.mv_size = sizeof(txn->mt_txnid);
2700                         key.mv_data = &txn->mt_txnid;
2701                         do {
2702                                 freecnt = free_pgs[0];
2703                                 data.mv_size = MDB_IDL_SIZEOF(free_pgs);
2704                                 rc = mdb_cursor_put(&mc, &key, &data, MDB_RESERVE);
2705                                 if (rc)
2706                                         return rc;
2707                                 /* Retry if mt_free_pgs[] grew during the Put() */
2708                                 free_pgs = txn->mt_free_pgs;
2709                         } while (freecnt < free_pgs[0]);
2710                         mdb_midl_sort(free_pgs);
2711                         memcpy(data.mv_data, free_pgs, data.mv_size);
2712 #if (MDB_DEBUG) > 1
2713                         {
2714                                 unsigned int i = free_pgs[0];
2715                                 DPRINTF(("IDL write txn %"Z"u root %"Z"u num %u",
2716                                         txn->mt_txnid, txn->mt_dbs[FREE_DBI].md_root, i));
2717                                 for (; i; i--)
2718                                         DPRINTF(("IDL %"Z"u", free_pgs[i]));
2719                         }
2720 #endif
2721                         continue;
2722                 }
2723
2724                 mop = env->me_pghead;
2725                 mop_len = mop ? mop[0] : 0;
2726
2727                 /* Reserve records for me_pghead[]. Split it if multi-page,
2728                  * to avoid searching freeDB for a page range. Use keys in
2729                  * range [1,me_pglast]: Smaller than txnid of oldest reader.
2730                  */
2731                 if (total_room >= mop_len) {
2732                         if (total_room == mop_len || --more < 0)
2733                                 break;
2734                 } else if (head_room >= maxfree_1pg && head_id > 1) {
2735                         /* Keep current record (overflow page), add a new one */
2736                         head_id--;
2737                         head_room = 0;
2738                 }
2739                 /* (Re)write {key = head_id, IDL length = head_room} */
2740                 total_room -= head_room;
2741                 head_room = mop_len - total_room;
2742                 if (head_room > maxfree_1pg && head_id > 1) {
2743                         /* Overflow multi-page for part of me_pghead */
2744                         head_room /= head_id; /* amortize page sizes */
2745                         head_room += maxfree_1pg - head_room % (maxfree_1pg + 1);
2746                 } else if (head_room < 0) {
2747                         /* Rare case, not bothering to delete this record */
2748                         head_room = 0;
2749                 }
2750                 key.mv_size = sizeof(head_id);
2751                 key.mv_data = &head_id;
2752                 data.mv_size = (head_room + 1) * sizeof(pgno_t);
2753                 rc = mdb_cursor_put(&mc, &key, &data, MDB_RESERVE);
2754                 if (rc)
2755                         return rc;
2756                 /* IDL is initially empty, zero out at least the length */
2757                 pgs = (pgno_t *)data.mv_data;
2758                 j = head_room > clean_limit ? head_room : 0;
2759                 do {
2760                         pgs[j] = 0;
2761                 } while (--j >= 0);
2762                 total_room += head_room;
2763         }
2764
2765         /* Fill in the reserved me_pghead records */
2766         rc = MDB_SUCCESS;
2767         if (mop_len) {
2768                 MDB_val key, data;
2769
2770                 mop += mop_len;
2771                 rc = mdb_cursor_first(&mc, &key, &data);
2772                 for (; !rc; rc = mdb_cursor_next(&mc, &key, &data, MDB_NEXT)) {
2773                         txnid_t id = *(txnid_t *)key.mv_data;
2774                         ssize_t len = (ssize_t)(data.mv_size / sizeof(MDB_ID)) - 1;
2775                         MDB_ID save;
2776
2777                         mdb_tassert(txn, len >= 0 && id <= env->me_pglast);
2778                         key.mv_data = &id;
2779                         if (len > mop_len) {
2780                                 len = mop_len;
2781                                 data.mv_size = (len + 1) * sizeof(MDB_ID);
2782                         }
2783                         data.mv_data = mop -= len;
2784                         save = mop[0];
2785                         mop[0] = len;
2786                         rc = mdb_cursor_put(&mc, &key, &data, MDB_CURRENT);
2787                         mop[0] = save;
2788                         if (rc || !(mop_len -= len))
2789                                 break;
2790                 }
2791         }
2792         return rc;
2793 }
2794
2795 /** Flush (some) dirty pages to the map, after clearing their dirty flag.
2796  * @param[in] txn the transaction that's being committed
2797  * @param[in] keep number of initial pages in dirty_list to keep dirty.
2798  * @return 0 on success, non-zero on failure.
2799  */
2800 static int
2801 mdb_page_flush(MDB_txn *txn, int keep)
2802 {
2803         MDB_env         *env = txn->mt_env;
2804         MDB_ID2L        dl = txn->mt_u.dirty_list;
2805         unsigned        psize = env->me_psize, j;
2806         int                     i, pagecount = dl[0].mid, rc;
2807         size_t          size = 0, pos = 0;
2808         pgno_t          pgno = 0;
2809         MDB_page        *dp = NULL;
2810 #ifdef _WIN32
2811         OVERLAPPED      ov;
2812 #else
2813         struct iovec iov[MDB_COMMIT_PAGES];
2814         ssize_t         wpos = 0, wsize = 0, wres;
2815         size_t          next_pos = 1; /* impossible pos, so pos != next_pos */
2816         int                     n = 0;
2817 #endif
2818
2819         j = i = keep;
2820
2821         if (env->me_flags & MDB_WRITEMAP) {
2822                 /* Clear dirty flags */
2823                 while (++i <= pagecount) {
2824                         dp = dl[i].mptr;
2825                         /* Don't flush this page yet */
2826                         if (dp->mp_flags & P_KEEP) {
2827                                 dp->mp_flags ^= P_KEEP;
2828                                 dl[++j] = dl[i];
2829                                 continue;
2830                         }
2831                         dp->mp_flags &= ~P_DIRTY;
2832                 }
2833                 goto done;
2834         }
2835
2836         /* Write the pages */
2837         for (;;) {
2838                 if (++i <= pagecount) {
2839                         dp = dl[i].mptr;
2840                         /* Don't flush this page yet */
2841                         if (dp->mp_flags & P_KEEP) {
2842                                 dp->mp_flags ^= P_KEEP;
2843                                 dl[i].mid = 0;
2844                                 continue;
2845                         }
2846                         pgno = dl[i].mid;
2847                         /* clear dirty flag */
2848                         dp->mp_flags &= ~P_DIRTY;
2849                         pos = pgno * psize;
2850                         size = psize;
2851                         if (IS_OVERFLOW(dp)) size *= dp->mp_pages;
2852                 }
2853 #ifdef _WIN32
2854                 else break;
2855
2856                 /* Windows actually supports scatter/gather I/O, but only on
2857                  * unbuffered file handles. Since we're relying on the OS page
2858                  * cache for all our data, that's self-defeating. So we just
2859                  * write pages one at a time. We use the ov structure to set
2860                  * the write offset, to at least save the overhead of a Seek
2861                  * system call.
2862                  */
2863                 DPRINTF(("committing page %"Z"u", pgno));
2864                 memset(&ov, 0, sizeof(ov));
2865                 ov.Offset = pos & 0xffffffff;
2866                 ov.OffsetHigh = pos >> 16 >> 16;
2867                 if (!WriteFile(env->me_fd, dp, size, NULL, &ov)) {
2868                         rc = ErrCode();
2869                         DPRINTF(("WriteFile: %d", rc));
2870                         return rc;
2871                 }
2872 #else
2873                 /* Write up to MDB_COMMIT_PAGES dirty pages at a time. */
2874                 if (pos!=next_pos || n==MDB_COMMIT_PAGES || wsize+size>MAX_WRITE) {
2875                         if (n) {
2876                                 /* Write previous page(s) */
2877 #ifdef MDB_USE_PWRITEV
2878                                 wres = pwritev(env->me_fd, iov, n, wpos);
2879 #else
2880                                 if (n == 1) {
2881                                         wres = pwrite(env->me_fd, iov[0].iov_base, wsize, wpos);
2882                                 } else {
2883                                         if (lseek(env->me_fd, wpos, SEEK_SET) == -1) {
2884                                                 rc = ErrCode();
2885                                                 DPRINTF(("lseek: %s", strerror(rc)));
2886                                                 return rc;
2887                                         }
2888                                         wres = writev(env->me_fd, iov, n);
2889                                 }
2890 #endif
2891                                 if (wres != wsize) {
2892                                         if (wres < 0) {
2893                                                 rc = ErrCode();
2894                                                 DPRINTF(("Write error: %s", strerror(rc)));
2895                                         } else {
2896                                                 rc = EIO; /* TODO: Use which error code? */
2897                                                 DPUTS("short write, filesystem full?");
2898                                         }
2899                                         return rc;
2900                                 }
2901                                 n = 0;
2902                         }
2903                         if (i > pagecount)
2904                                 break;
2905                         wpos = pos;
2906                         wsize = 0;
2907                 }
2908                 DPRINTF(("committing page %"Z"u", pgno));
2909                 next_pos = pos + size;
2910                 iov[n].iov_len = size;
2911                 iov[n].iov_base = (char *)dp;
2912                 wsize += size;
2913                 n++;
2914 #endif  /* _WIN32 */
2915         }
2916
2917         for (i = keep; ++i <= pagecount; ) {
2918                 dp = dl[i].mptr;
2919                 /* This is a page we skipped above */
2920                 if (!dl[i].mid) {
2921                         dl[++j] = dl[i];
2922                         dl[j].mid = dp->mp_pgno;
2923                         continue;
2924                 }
2925                 mdb_dpage_free(env, dp);
2926         }
2927
2928 done:
2929         i--;
2930         txn->mt_dirty_room += i - j;
2931         dl[0].mid = j;
2932         return MDB_SUCCESS;
2933 }
2934
2935 int
2936 mdb_txn_commit(MDB_txn *txn)
2937 {
2938         int             rc;
2939         unsigned int i;
2940         MDB_env *env;
2941
2942         if (txn == NULL || txn->mt_env == NULL)
2943                 return EINVAL;
2944
2945         if (txn->mt_child) {
2946                 rc = mdb_txn_commit(txn->mt_child);
2947                 txn->mt_child = NULL;
2948                 if (rc)
2949                         goto fail;
2950         }
2951
2952         env = txn->mt_env;
2953
2954         if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY)) {
2955                 mdb_dbis_update(txn, 1);
2956                 txn->mt_numdbs = 2; /* so txn_abort() doesn't close any new handles */
2957                 mdb_txn_abort(txn);
2958                 return MDB_SUCCESS;
2959         }
2960
2961         if (F_ISSET(txn->mt_flags, MDB_TXN_ERROR)) {
2962                 DPUTS("error flag is set, can't commit");
2963                 if (txn->mt_parent)
2964                         txn->mt_parent->mt_flags |= MDB_TXN_ERROR;
2965                 rc = MDB_BAD_TXN;
2966                 goto fail;
2967         }
2968
2969         if (txn->mt_parent) {
2970                 MDB_txn *parent = txn->mt_parent;
2971                 MDB_ID2L dst, src;
2972                 MDB_IDL pspill;
2973                 unsigned x, y, len, ps_len;
2974
2975                 /* Append our free list to parent's */
2976                 rc = mdb_midl_append_list(&parent->mt_free_pgs, txn->mt_free_pgs);
2977                 if (rc)
2978                         goto fail;
2979                 mdb_midl_free(txn->mt_free_pgs);
2980                 /* Failures after this must either undo the changes
2981                  * to the parent or set MDB_TXN_ERROR in the parent.
2982                  */
2983
2984                 parent->mt_next_pgno = txn->mt_next_pgno;
2985                 parent->mt_flags = txn->mt_flags;
2986
2987                 /* Merge our cursors into parent's and close them */
2988                 mdb_cursors_close(txn, 1);
2989
2990                 /* Update parent's DB table. */
2991                 memcpy(parent->mt_dbs, txn->mt_dbs, txn->mt_numdbs * sizeof(MDB_db));
2992                 parent->mt_numdbs = txn->mt_numdbs;
2993                 parent->mt_dbflags[0] = txn->mt_dbflags[0];
2994                 parent->mt_dbflags[1] = txn->mt_dbflags[1];
2995                 for (i=2; i<txn->mt_numdbs; i++) {
2996                         /* preserve parent's DB_NEW status */
2997                         x = parent->mt_dbflags[i] & DB_NEW;
2998                         parent->mt_dbflags[i] = txn->mt_dbflags[i] | x;
2999                 }
3000
3001                 dst = parent->mt_u.dirty_list;
3002                 src = txn->mt_u.dirty_list;
3003                 /* Remove anything in our dirty list from parent's spill list */
3004                 if ((pspill = parent->mt_spill_pgs) && (ps_len = pspill[0])) {
3005                         x = y = ps_len;
3006                         pspill[0] = (pgno_t)-1;
3007                         /* Mark our dirty pages as deleted in parent spill list */
3008                         for (i=0, len=src[0].mid; ++i <= len; ) {
3009                                 MDB_ID pn = src[i].mid << 1;
3010                                 while (pn > pspill[x])
3011                                         x--;
3012                                 if (pn == pspill[x]) {
3013                                         pspill[x] = 1;
3014                                         y = --x;
3015                                 }
3016                         }
3017                         /* Squash deleted pagenums if we deleted any */
3018                         for (x=y; ++x <= ps_len; )
3019                                 if (!(pspill[x] & 1))
3020                                         pspill[++y] = pspill[x];
3021                         pspill[0] = y;
3022                 }
3023
3024                 /* Find len = length of merging our dirty list with parent's */
3025                 x = dst[0].mid;
3026                 dst[0].mid = 0;         /* simplify loops */
3027                 if (parent->mt_parent) {
3028                         len = x + src[0].mid;
3029                         y = mdb_mid2l_search(src, dst[x].mid + 1) - 1;
3030                         for (i = x; y && i; y--) {
3031                                 pgno_t yp = src[y].mid;
3032                                 while (yp < dst[i].mid)
3033                                         i--;
3034                                 if (yp == dst[i].mid) {
3035                                         i--;
3036                                         len--;
3037                                 }
3038                         }
3039                 } else { /* Simplify the above for single-ancestor case */
3040                         len = MDB_IDL_UM_MAX - txn->mt_dirty_room;
3041                 }
3042                 /* Merge our dirty list with parent's */
3043                 y = src[0].mid;
3044                 for (i = len; y; dst[i--] = src[y--]) {
3045                         pgno_t yp = src[y].mid;
3046                         while (yp < dst[x].mid)
3047                                 dst[i--] = dst[x--];
3048                         if (yp == dst[x].mid)
3049                                 free(dst[x--].mptr);
3050                 }
3051                 mdb_tassert(txn, i == x);
3052                 dst[0].mid = len;
3053                 free(txn->mt_u.dirty_list);
3054                 parent->mt_dirty_room = txn->mt_dirty_room;
3055                 if (txn->mt_spill_pgs) {
3056                         if (parent->mt_spill_pgs) {
3057                                 /* TODO: Prevent failure here, so parent does not fail */
3058                                 rc = mdb_midl_append_list(&parent->mt_spill_pgs, txn->mt_spill_pgs);
3059                                 if (rc)
3060                                         parent->mt_flags |= MDB_TXN_ERROR;
3061                                 mdb_midl_free(txn->mt_spill_pgs);
3062                                 mdb_midl_sort(parent->mt_spill_pgs);
3063                         } else {
3064                                 parent->mt_spill_pgs = txn->mt_spill_pgs;
3065                         }
3066                 }
3067
3068                 parent->mt_child = NULL;
3069                 mdb_midl_free(((MDB_ntxn *)txn)->mnt_pgstate.mf_pghead);
3070                 free(txn);
3071                 return rc;
3072         }
3073
3074         if (txn != env->me_txn) {
3075                 DPUTS("attempt to commit unknown transaction");
3076                 rc = EINVAL;
3077                 goto fail;
3078         }
3079
3080         mdb_cursors_close(txn, 0);
3081
3082         if (!txn->mt_u.dirty_list[0].mid &&
3083                 !(txn->mt_flags & (MDB_TXN_DIRTY|MDB_TXN_SPILLS)))
3084                 goto done;
3085
3086         DPRINTF(("committing txn %"Z"u %p on mdbenv %p, root page %"Z"u",
3087             txn->mt_txnid, (void*)txn, (void*)env, txn->mt_dbs[MAIN_DBI].md_root));
3088
3089         /* Update DB root pointers */
3090         if (txn->mt_numdbs > 2) {
3091                 MDB_cursor mc;
3092                 MDB_dbi i;
3093                 MDB_val data;
3094                 data.mv_size = sizeof(MDB_db);
3095
3096                 mdb_cursor_init(&mc, txn, MAIN_DBI, NULL);
3097                 for (i = 2; i < txn->mt_numdbs; i++) {
3098                         if (txn->mt_dbflags[i] & DB_DIRTY) {
3099                                 data.mv_data = &txn->mt_dbs[i];
3100                                 rc = mdb_cursor_put(&mc, &txn->mt_dbxs[i].md_name, &data, 0);
3101                                 if (rc)
3102                                         goto fail;
3103                         }
3104                 }
3105         }
3106
3107         rc = mdb_freelist_save(txn);
3108         if (rc)
3109                 goto fail;
3110
3111         mdb_midl_free(env->me_pghead);
3112         env->me_pghead = NULL;
3113         if (mdb_midl_shrink(&txn->mt_free_pgs))
3114                 env->me_free_pgs = txn->mt_free_pgs;
3115
3116 #if (MDB_DEBUG) > 2
3117         mdb_audit(txn);
3118 #endif
3119
3120         if ((rc = mdb_page_flush(txn, 0)) ||
3121                 (rc = mdb_env_sync(env, 0)) ||
3122                 (rc = mdb_env_write_meta(txn)))
3123                 goto fail;
3124
3125 done:
3126         env->me_pglast = 0;
3127         env->me_txn = NULL;
3128         mdb_dbis_update(txn, 1);
3129
3130         if (env->me_txns)
3131                 UNLOCK_MUTEX_W(env);
3132         free(txn);
3133
3134         return MDB_SUCCESS;
3135
3136 fail:
3137         mdb_txn_abort(txn);
3138         return rc;
3139 }
3140
3141 /** Read the environment parameters of a DB environment before
3142  * mapping it into memory.
3143  * @param[in] env the environment handle
3144  * @param[out] meta address of where to store the meta information
3145  * @return 0 on success, non-zero on failure.
3146  */
3147 static int
3148 mdb_env_read_header(MDB_env *env, MDB_meta *meta)
3149 {
3150         MDB_metabuf     pbuf;
3151         MDB_page        *p;
3152         MDB_meta        *m;
3153         int                     i, rc, off;
3154         enum { Size = sizeof(pbuf) };
3155
3156         /* We don't know the page size yet, so use a minimum value.
3157          * Read both meta pages so we can use the latest one.
3158          */
3159
3160         for (i=off=0; i<2; i++, off = meta->mm_psize) {
3161 #ifdef _WIN32
3162                 DWORD len;
3163                 OVERLAPPED ov;
3164                 memset(&ov, 0, sizeof(ov));
3165                 ov.Offset = off;
3166                 rc = ReadFile(env->me_fd, &pbuf, Size, &len, &ov) ? (int)len : -1;
3167                 if (rc == -1 && ErrCode() == ERROR_HANDLE_EOF)
3168                         rc = 0;
3169 #else
3170                 rc = pread(env->me_fd, &pbuf, Size, off);
3171 #endif
3172                 if (rc != Size) {
3173                         if (rc == 0 && off == 0)
3174                                 return ENOENT;
3175                         rc = rc < 0 ? (int) ErrCode() : MDB_INVALID;
3176                         DPRINTF(("read: %s", mdb_strerror(rc)));
3177                         return rc;
3178                 }
3179
3180                 p = (MDB_page *)&pbuf;
3181
3182                 if (!F_ISSET(p->mp_flags, P_META)) {
3183                         DPRINTF(("page %"Z"u not a meta page", p->mp_pgno));
3184                         return MDB_INVALID;
3185                 }
3186
3187                 m = METADATA(p);
3188                 if (m->mm_magic != MDB_MAGIC) {
3189                         DPUTS("meta has invalid magic");
3190                         return MDB_INVALID;
3191                 }
3192
3193                 if (m->mm_version != MDB_DATA_VERSION) {
3194                         DPRINTF(("database is version %u, expected version %u",
3195                                 m->mm_version, MDB_DATA_VERSION));
3196                         return MDB_VERSION_MISMATCH;
3197                 }
3198
3199                 if (off == 0 || m->mm_txnid > meta->mm_txnid)
3200                         *meta = *m;
3201         }
3202         return 0;
3203 }
3204
3205 /** Write the environment parameters of a freshly created DB environment.
3206  * @param[in] env the environment handle
3207  * @param[out] meta address of where to store the meta information
3208  * @return 0 on success, non-zero on failure.
3209  */
3210 static int
3211 mdb_env_init_meta(MDB_env *env, MDB_meta *meta)
3212 {
3213         MDB_page *p, *q;
3214         int rc;
3215         unsigned int     psize;
3216 #ifdef _WIN32
3217         DWORD len;
3218         OVERLAPPED ov;
3219         memset(&ov, 0, sizeof(ov));
3220 #define DO_PWRITE(rc, fd, ptr, size, len, pos)  do { \
3221         ov.Offset = pos;        \
3222         rc = WriteFile(fd, ptr, size, &len, &ov);       } while(0)
3223 #else
3224         int len;
3225 #define DO_PWRITE(rc, fd, ptr, size, len, pos)  do { \
3226         len = pwrite(fd, ptr, size, pos);       \
3227         rc = (len >= 0); } while(0)
3228 #endif
3229
3230         DPUTS("writing new meta page");
3231
3232         psize = env->me_psize;
3233
3234         meta->mm_magic = MDB_MAGIC;
3235         meta->mm_version = MDB_DATA_VERSION;
3236         meta->mm_mapsize = env->me_mapsize;
3237         meta->mm_psize = psize;
3238         meta->mm_last_pg = 1;
3239         meta->mm_flags = env->me_flags & 0xffff;
3240         meta->mm_flags |= MDB_INTEGERKEY;
3241         meta->mm_dbs[0].md_root = P_INVALID;
3242         meta->mm_dbs[1].md_root = P_INVALID;
3243
3244         p = calloc(2, psize);
3245         p->mp_pgno = 0;
3246         p->mp_flags = P_META;
3247         *(MDB_meta *)METADATA(p) = *meta;
3248
3249         q = (MDB_page *)((char *)p + psize);
3250         q->mp_pgno = 1;
3251         q->mp_flags = P_META;
3252         *(MDB_meta *)METADATA(q) = *meta;
3253
3254         DO_PWRITE(rc, env->me_fd, p, psize * 2, len, 0);
3255         if (!rc)
3256                 rc = ErrCode();
3257         else if ((unsigned) len == psize * 2)
3258                 rc = MDB_SUCCESS;
3259         else
3260                 rc = ENOSPC;
3261         free(p);
3262         return rc;
3263 }
3264
3265 /** Update the environment info to commit a transaction.
3266  * @param[in] txn the transaction that's being committed
3267  * @return 0 on success, non-zero on failure.
3268  */
3269 static int
3270 mdb_env_write_meta(MDB_txn *txn)
3271 {
3272         MDB_env *env;
3273         MDB_meta        meta, metab, *mp;
3274         off_t off;
3275         int rc, len, toggle;
3276         char *ptr;
3277         HANDLE mfd;
3278 #ifdef _WIN32
3279         OVERLAPPED ov;
3280 #else
3281         int r2;
3282 #endif
3283
3284         toggle = txn->mt_txnid & 1;
3285         DPRINTF(("writing meta page %d for root page %"Z"u",
3286                 toggle, txn->mt_dbs[MAIN_DBI].md_root));
3287
3288         env = txn->mt_env;
3289         mp = env->me_metas[toggle];
3290
3291         if (env->me_flags & MDB_WRITEMAP) {
3292                 /* Persist any increases of mapsize config */
3293                 if (env->me_mapsize > mp->mm_mapsize)
3294                         mp->mm_mapsize = env->me_mapsize;
3295                 mp->mm_dbs[0] = txn->mt_dbs[0];
3296                 mp->mm_dbs[1] = txn->mt_dbs[1];
3297                 mp->mm_last_pg = txn->mt_next_pgno - 1;
3298                 mp->mm_txnid = txn->mt_txnid;
3299                 if (!(env->me_flags & (MDB_NOMETASYNC|MDB_NOSYNC))) {
3300                         unsigned meta_size = env->me_psize;
3301                         rc = (env->me_flags & MDB_MAPASYNC) ? MS_ASYNC : MS_SYNC;
3302                         ptr = env->me_map;
3303                         if (toggle) {
3304 #ifndef _WIN32  /* POSIX msync() requires ptr = start of OS page */
3305                                 if (meta_size < env->me_os_psize)
3306                                         meta_size += meta_size;
3307                                 else
3308 #endif
3309                                         ptr += meta_size;
3310                         }
3311                         if (MDB_MSYNC(ptr, meta_size, rc)) {
3312                                 rc = ErrCode();
3313                                 goto fail;
3314                         }
3315                 }
3316                 goto done;
3317         }
3318         metab.mm_txnid = env->me_metas[toggle]->mm_txnid;
3319         metab.mm_last_pg = env->me_metas[toggle]->mm_last_pg;
3320
3321         ptr = (char *)&meta;
3322         if (env->me_mapsize > mp->mm_mapsize) {
3323                 /* Persist any increases of mapsize config */
3324                 meta.mm_mapsize = env->me_mapsize;
3325                 off = offsetof(MDB_meta, mm_mapsize);
3326         } else {
3327                 off = offsetof(MDB_meta, mm_dbs[0].md_depth);
3328         }
3329         len = sizeof(MDB_meta) - off;
3330
3331         ptr += off;
3332         meta.mm_dbs[0] = txn->mt_dbs[0];
3333         meta.mm_dbs[1] = txn->mt_dbs[1];
3334         meta.mm_last_pg = txn->mt_next_pgno - 1;
3335         meta.mm_txnid = txn->mt_txnid;
3336
3337         if (toggle)
3338                 off += env->me_psize;
3339         off += PAGEHDRSZ;
3340
3341         /* Write to the SYNC fd */
3342         mfd = env->me_flags & (MDB_NOSYNC|MDB_NOMETASYNC) ?
3343                 env->me_fd : env->me_mfd;
3344 #ifdef _WIN32
3345         {
3346                 memset(&ov, 0, sizeof(ov));
3347                 ov.Offset = off;
3348                 if (!WriteFile(mfd, ptr, len, (DWORD *)&rc, &ov))
3349                         rc = -1;
3350         }
3351 #else
3352         rc = pwrite(mfd, ptr, len, off);
3353 #endif
3354         if (rc != len) {
3355                 rc = rc < 0 ? ErrCode() : EIO;
3356                 DPUTS("write failed, disk error?");
3357                 /* On a failure, the pagecache still contains the new data.
3358                  * Write some old data back, to prevent it from being used.
3359                  * Use the non-SYNC fd; we know it will fail anyway.
3360                  */
3361                 meta.mm_last_pg = metab.mm_last_pg;
3362                 meta.mm_txnid = metab.mm_txnid;
3363 #ifdef _WIN32
3364                 memset(&ov, 0, sizeof(ov));
3365                 ov.Offset = off;
3366                 WriteFile(env->me_fd, ptr, len, NULL, &ov);
3367 #else
3368                 r2 = pwrite(env->me_fd, ptr, len, off);
3369                 (void)r2;       /* Silence warnings. We don't care about pwrite's return value */
3370 #endif
3371 fail:
3372                 env->me_flags |= MDB_FATAL_ERROR;
3373                 return rc;
3374         }
3375 done:
3376         /* Memory ordering issues are irrelevant; since the entire writer
3377          * is wrapped by wmutex, all of these changes will become visible
3378          * after the wmutex is unlocked. Since the DB is multi-version,
3379          * readers will get consistent data regardless of how fresh or
3380          * how stale their view of these values is.
3381          */
3382         if (env->me_txns)
3383                 env->me_txns->mti_txnid = txn->mt_txnid;
3384
3385         return MDB_SUCCESS;
3386 }
3387
3388 /** Check both meta pages to see which one is newer.
3389  * @param[in] env the environment handle
3390  * @return meta toggle (0 or 1).
3391  */
3392 static int
3393 mdb_env_pick_meta(const MDB_env *env)
3394 {
3395         return (env->me_metas[0]->mm_txnid < env->me_metas[1]->mm_txnid);
3396 }
3397
3398 int
3399 mdb_env_create(MDB_env **env)
3400 {
3401         MDB_env *e;
3402
3403         e = calloc(1, sizeof(MDB_env));
3404         if (!e)
3405                 return ENOMEM;
3406
3407         e->me_maxreaders = DEFAULT_READERS;
3408         e->me_maxdbs = e->me_numdbs = 2;
3409         e->me_fd = INVALID_HANDLE_VALUE;
3410         e->me_lfd = INVALID_HANDLE_VALUE;
3411         e->me_mfd = INVALID_HANDLE_VALUE;
3412 #ifdef MDB_USE_POSIX_SEM
3413         e->me_rmutex = SEM_FAILED;
3414         e->me_wmutex = SEM_FAILED;
3415 #endif
3416         e->me_pid = getpid();
3417         GET_PAGESIZE(e->me_os_psize);
3418         VGMEMP_CREATE(e,0,0);
3419         *env = e;
3420         return MDB_SUCCESS;
3421 }
3422
3423 static int
3424 mdb_env_map(MDB_env *env, void *addr, int newsize)
3425 {
3426         MDB_page *p;
3427         unsigned int flags = env->me_flags;
3428 #ifdef _WIN32
3429         int rc;
3430         HANDLE mh;
3431         LONG sizelo, sizehi;
3432         sizelo = env->me_mapsize & 0xffffffff;
3433         sizehi = env->me_mapsize >> 16 >> 16; /* only needed on Win64 */
3434
3435         /* Windows won't create mappings for zero length files.
3436          * Just allocate the maxsize right now.
3437          */
3438         if (newsize) {
3439                 if (SetFilePointer(env->me_fd, sizelo, &sizehi, 0) != (DWORD)sizelo
3440                         || !SetEndOfFile(env->me_fd)
3441                         || SetFilePointer(env->me_fd, 0, NULL, 0) != 0)
3442                         return ErrCode();
3443         }
3444         mh = CreateFileMapping(env->me_fd, NULL, flags & MDB_WRITEMAP ?
3445                 PAGE_READWRITE : PAGE_READONLY,
3446                 sizehi, sizelo, NULL);
3447         if (!mh)
3448                 return ErrCode();
3449         env->me_map = MapViewOfFileEx(mh, flags & MDB_WRITEMAP ?
3450                 FILE_MAP_WRITE : FILE_MAP_READ,
3451                 0, 0, env->me_mapsize, addr);
3452         rc = env->me_map ? 0 : ErrCode();
3453         CloseHandle(mh);
3454         if (rc)
3455                 return rc;
3456 #else
3457         int prot = PROT_READ;
3458         if (flags & MDB_WRITEMAP) {
3459                 prot |= PROT_WRITE;
3460                 if (ftruncate(env->me_fd, env->me_mapsize) < 0)
3461                         return ErrCode();
3462         }
3463         env->me_map = mmap(addr, env->me_mapsize, prot, MAP_SHARED,
3464                 env->me_fd, 0);
3465         if (env->me_map == MAP_FAILED) {
3466                 env->me_map = NULL;
3467                 return ErrCode();
3468         }
3469
3470         if (flags & MDB_NORDAHEAD) {
3471                 /* Turn off readahead. It's harmful when the DB is larger than RAM. */
3472 #ifdef MADV_RANDOM
3473                 madvise(env->me_map, env->me_mapsize, MADV_RANDOM);
3474 #else
3475 #ifdef POSIX_MADV_RANDOM
3476                 posix_madvise(env->me_map, env->me_mapsize, POSIX_MADV_RANDOM);
3477 #endif /* POSIX_MADV_RANDOM */
3478 #endif /* MADV_RANDOM */
3479         }
3480 #endif /* _WIN32 */
3481
3482         /* Can happen because the address argument to mmap() is just a
3483          * hint.  mmap() can pick another, e.g. if the range is in use.
3484          * The MAP_FIXED flag would prevent that, but then mmap could
3485          * instead unmap existing pages to make room for the new map.
3486          */
3487         if (addr && env->me_map != addr)
3488                 return EBUSY;   /* TODO: Make a new MDB_* error code? */
3489
3490         p = (MDB_page *)env->me_map;
3491         env->me_metas[0] = METADATA(p);
3492         env->me_metas[1] = (MDB_meta *)((char *)env->me_metas[0] + env->me_psize);
3493
3494         return MDB_SUCCESS;
3495 }
3496
3497 int
3498 mdb_env_set_mapsize(MDB_env *env, size_t size)
3499 {
3500         /* If env is already open, caller is responsible for making
3501          * sure there are no active txns.
3502          */
3503         if (env->me_map) {
3504                 int rc;
3505                 void *old;
3506                 if (env->me_txn)
3507                         return EINVAL;
3508                 if (!size)
3509                         size = env->me_metas[mdb_env_pick_meta(env)]->mm_mapsize;
3510                 else if (size < env->me_mapsize) {
3511                         /* If the configured size is smaller, make sure it's
3512                          * still big enough. Silently round up to minimum if not.
3513                          */
3514                         size_t minsize = (env->me_metas[mdb_env_pick_meta(env)]->mm_last_pg + 1) * env->me_psize;
3515                         if (size < minsize)
3516                                 size = minsize;
3517                 }
3518                 munmap(env->me_map, env->me_mapsize);
3519                 env->me_mapsize = size;
3520                 old = (env->me_flags & MDB_FIXEDMAP) ? env->me_map : NULL;
3521                 rc = mdb_env_map(env, old, 1);
3522                 if (rc)
3523                         return rc;
3524         }
3525         env->me_mapsize = size;
3526         if (env->me_psize)
3527                 env->me_maxpg = env->me_mapsize / env->me_psize;
3528         return MDB_SUCCESS;
3529 }
3530
3531 int
3532 mdb_env_set_maxdbs(MDB_env *env, MDB_dbi dbs)
3533 {
3534         if (env->me_map)
3535                 return EINVAL;
3536         env->me_maxdbs = dbs + 2; /* Named databases + main and free DB */
3537         return MDB_SUCCESS;
3538 }
3539
3540 int
3541 mdb_env_set_maxreaders(MDB_env *env, unsigned int readers)
3542 {
3543         if (env->me_map || readers < 1)
3544                 return EINVAL;
3545         env->me_maxreaders = readers;
3546         return MDB_SUCCESS;
3547 }
3548
3549 int
3550 mdb_env_get_maxreaders(MDB_env *env, unsigned int *readers)
3551 {
3552         if (!env || !readers)
3553                 return EINVAL;
3554         *readers = env->me_maxreaders;
3555         return MDB_SUCCESS;
3556 }
3557
3558 /** Further setup required for opening an MDB environment
3559  */
3560 static int
3561 mdb_env_open2(MDB_env *env)
3562 {
3563         unsigned int flags = env->me_flags;
3564         int i, newenv = 0, rc;
3565         MDB_meta meta;
3566
3567 #ifdef _WIN32
3568         /* See if we should use QueryLimited */
3569         rc = GetVersion();
3570         if ((rc & 0xff) > 5)
3571                 env->me_pidquery = MDB_PROCESS_QUERY_LIMITED_INFORMATION;
3572         else
3573                 env->me_pidquery = PROCESS_QUERY_INFORMATION;
3574 #endif /* _WIN32 */
3575
3576         memset(&meta, 0, sizeof(meta));
3577
3578         if ((i = mdb_env_read_header(env, &meta)) != 0) {
3579                 if (i != ENOENT)
3580                         return i;
3581                 DPUTS("new mdbenv");
3582                 newenv = 1;
3583                 env->me_psize = env->me_os_psize;
3584                 if (env->me_psize > MAX_PAGESIZE)
3585                         env->me_psize = MAX_PAGESIZE;
3586         } else {
3587                 env->me_psize = meta.mm_psize;
3588         }
3589
3590         /* Was a mapsize configured? */
3591         if (!env->me_mapsize) {
3592                 /* If this is a new environment, take the default,
3593                  * else use the size recorded in the existing env.
3594                  */
3595                 env->me_mapsize = newenv ? DEFAULT_MAPSIZE : meta.mm_mapsize;
3596         } else if (env->me_mapsize < meta.mm_mapsize) {
3597                 /* If the configured size is smaller, make sure it's
3598                  * still big enough. Silently round up to minimum if not.
3599                  */
3600                 size_t minsize = (meta.mm_last_pg + 1) * meta.mm_psize;
3601                 if (env->me_mapsize < minsize)
3602                         env->me_mapsize = minsize;
3603         }
3604
3605         rc = mdb_env_map(env, meta.mm_address, newenv || env->me_mapsize != meta.mm_mapsize);
3606         if (rc)
3607                 return rc;
3608
3609         if (newenv) {
3610                 if (flags & MDB_FIXEDMAP)
3611                         meta.mm_address = env->me_map;
3612                 i = mdb_env_init_meta(env, &meta);
3613                 if (i != MDB_SUCCESS) {
3614                         return i;
3615                 }
3616         }
3617
3618         env->me_maxfree_1pg = (env->me_psize - PAGEHDRSZ) / sizeof(pgno_t) - 1;
3619         env->me_nodemax = (((env->me_psize - PAGEHDRSZ) / MDB_MINKEYS) & -2)
3620                 - sizeof(indx_t);
3621 #if !(MDB_MAXKEYSIZE)
3622         env->me_maxkey = env->me_nodemax - (NODESIZE + sizeof(MDB_db));
3623 #endif
3624         env->me_maxpg = env->me_mapsize / env->me_psize;
3625
3626 #if MDB_DEBUG
3627         {
3628                 int toggle = mdb_env_pick_meta(env);
3629                 MDB_db *db = &env->me_metas[toggle]->mm_dbs[MAIN_DBI];
3630
3631                 DPRINTF(("opened database version %u, pagesize %u",
3632                         env->me_metas[0]->mm_version, env->me_psize));
3633                 DPRINTF(("using meta page %d",    toggle));
3634                 DPRINTF(("depth: %u",             db->md_depth));
3635                 DPRINTF(("entries: %"Z"u",        db->md_entries));
3636                 DPRINTF(("branch pages: %"Z"u",   db->md_branch_pages));
3637                 DPRINTF(("leaf pages: %"Z"u",     db->md_leaf_pages));
3638                 DPRINTF(("overflow pages: %"Z"u", db->md_overflow_pages));
3639                 DPRINTF(("root: %"Z"u",           db->md_root));
3640         }
3641 #endif
3642
3643         return MDB_SUCCESS;
3644 }
3645
3646
3647 /** Release a reader thread's slot in the reader lock table.
3648  *      This function is called automatically when a thread exits.
3649  * @param[in] ptr This points to the slot in the reader lock table.
3650  */
3651 static void
3652 mdb_env_reader_dest(void *ptr)
3653 {
3654         MDB_reader *reader = ptr;
3655
3656         reader->mr_pid = 0;
3657 }
3658
3659 #ifdef _WIN32
3660 /** Junk for arranging thread-specific callbacks on Windows. This is
3661  *      necessarily platform and compiler-specific. Windows supports up
3662  *      to 1088 keys. Let's assume nobody opens more than 64 environments
3663  *      in a single process, for now. They can override this if needed.
3664  */
3665 #ifndef MAX_TLS_KEYS
3666 #define MAX_TLS_KEYS    64
3667 #endif
3668 static pthread_key_t mdb_tls_keys[MAX_TLS_KEYS];
3669 static int mdb_tls_nkeys;
3670
3671 static void NTAPI mdb_tls_callback(PVOID module, DWORD reason, PVOID ptr)
3672 {
3673         int i;
3674         switch(reason) {
3675         case DLL_PROCESS_ATTACH: break;
3676         case DLL_THREAD_ATTACH: break;
3677         case DLL_THREAD_DETACH:
3678                 for (i=0; i<mdb_tls_nkeys; i++) {
3679                         MDB_reader *r = pthread_getspecific(mdb_tls_keys[i]);
3680                         mdb_env_reader_dest(r);
3681                 }
3682                 break;
3683         case DLL_PROCESS_DETACH: break;
3684         }
3685 }
3686 #ifdef __GNUC__
3687 #ifdef _WIN64
3688 const PIMAGE_TLS_CALLBACK mdb_tls_cbp __attribute__((section (".CRT$XLB"))) = mdb_tls_callback;
3689 #else
3690 PIMAGE_TLS_CALLBACK mdb_tls_cbp __attribute__((section (".CRT$XLB"))) = mdb_tls_callback;
3691 #endif
3692 #else
3693 #ifdef _WIN64
3694 /* Force some symbol references.
3695  *      _tls_used forces the linker to create the TLS directory if not already done
3696  *      mdb_tls_cbp prevents whole-program-optimizer from dropping the symbol.
3697  */
3698 #pragma comment(linker, "/INCLUDE:_tls_used")
3699 #pragma comment(linker, "/INCLUDE:mdb_tls_cbp")
3700 #pragma const_seg(".CRT$XLB")
3701 extern const PIMAGE_TLS_CALLBACK mdb_tls_cbp;
3702 const PIMAGE_TLS_CALLBACK mdb_tls_cbp = mdb_tls_callback;
3703 #pragma const_seg()
3704 #else   /* WIN32 */
3705 #pragma comment(linker, "/INCLUDE:__tls_used")
3706 #pragma comment(linker, "/INCLUDE:_mdb_tls_cbp")
3707 #pragma data_seg(".CRT$XLB")
3708 PIMAGE_TLS_CALLBACK mdb_tls_cbp = mdb_tls_callback;
3709 #pragma data_seg()
3710 #endif  /* WIN 32/64 */
3711 #endif  /* !__GNUC__ */
3712 #endif
3713
3714 /** Downgrade the exclusive lock on the region back to shared */
3715 static int
3716 mdb_env_share_locks(MDB_env *env, int *excl)
3717 {
3718         int rc = 0, toggle = mdb_env_pick_meta(env);
3719
3720         env->me_txns->mti_txnid = env->me_metas[toggle]->mm_txnid;
3721
3722 #ifdef _WIN32
3723         {
3724                 OVERLAPPED ov;
3725                 /* First acquire a shared lock. The Unlock will
3726                  * then release the existing exclusive lock.
3727                  */
3728                 memset(&ov, 0, sizeof(ov));
3729                 if (!LockFileEx(env->me_lfd, 0, 0, 1, 0, &ov)) {
3730                         rc = ErrCode();
3731                 } else {
3732                         UnlockFile(env->me_lfd, 0, 0, 1, 0);
3733                         *excl = 0;
3734                 }
3735         }
3736 #else
3737         {
3738                 struct flock lock_info;
3739                 /* The shared lock replaces the existing lock */
3740                 memset((void *)&lock_info, 0, sizeof(lock_info));
3741                 lock_info.l_type = F_RDLCK;
3742                 lock_info.l_whence = SEEK_SET;
3743                 lock_info.l_start = 0;
3744                 lock_info.l_len = 1;
3745                 while ((rc = fcntl(env->me_lfd, F_SETLK, &lock_info)) &&
3746                                 (rc = ErrCode()) == EINTR) ;
3747                 *excl = rc ? -1 : 0;    /* error may mean we lost the lock */
3748         }
3749 #endif
3750
3751         return rc;
3752 }
3753
3754 /** Try to get exlusive lock, otherwise shared.
3755  *      Maintain *excl = -1: no/unknown lock, 0: shared, 1: exclusive.
3756  */
3757 static int
3758 mdb_env_excl_lock(MDB_env *env, int *excl)
3759 {
3760         int rc = 0;
3761 #ifdef _WIN32
3762         if (LockFile(env->me_lfd, 0, 0, 1, 0)) {
3763                 *excl = 1;
3764         } else {
3765                 OVERLAPPED ov;
3766                 memset(&ov, 0, sizeof(ov));
3767                 if (LockFileEx(env->me_lfd, 0, 0, 1, 0, &ov)) {
3768                         *excl = 0;
3769                 } else {
3770                         rc = ErrCode();
3771                 }
3772         }
3773 #else
3774         struct flock lock_info;
3775         memset((void *)&lock_info, 0, sizeof(lock_info));
3776         lock_info.l_type = F_WRLCK;
3777         lock_info.l_whence = SEEK_SET;
3778         lock_info.l_start = 0;
3779         lock_info.l_len = 1;
3780         while ((rc = fcntl(env->me_lfd, F_SETLK, &lock_info)) &&
3781                         (rc = ErrCode()) == EINTR) ;
3782         if (!rc) {
3783                 *excl = 1;
3784         } else
3785 # ifdef MDB_USE_POSIX_SEM
3786         if (*excl < 0) /* always true when !MDB_USE_POSIX_SEM */
3787 # endif
3788         {
3789                 lock_info.l_type = F_RDLCK;
3790                 while ((rc = fcntl(env->me_lfd, F_SETLKW, &lock_info)) &&
3791                                 (rc = ErrCode()) == EINTR) ;
3792                 if (rc == 0)
3793                         *excl = 0;
3794         }
3795 #endif
3796         return rc;
3797 }
3798
3799 #ifdef MDB_USE_HASH
3800 /*
3801  * hash_64 - 64 bit Fowler/Noll/Vo-0 FNV-1a hash code
3802  *
3803  * @(#) $Revision: 5.1 $
3804  * @(#) $Id: hash_64a.c,v 5.1 2009/06/30 09:01:38 chongo Exp $
3805  * @(#) $Source: /usr/local/src/cmd/fnv/RCS/hash_64a.c,v $
3806  *
3807  *        http://www.isthe.com/chongo/tech/comp/fnv/index.html
3808  *
3809  ***
3810  *
3811  * Please do not copyright this code.  This code is in the public domain.
3812  *
3813  * LANDON CURT NOLL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
3814  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
3815  * EVENT SHALL LANDON CURT NOLL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
3816  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
3817  * USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
3818  * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
3819  * PERFORMANCE OF THIS SOFTWARE.
3820  *
3821  * By:
3822  *      chongo <Landon Curt Noll> /\oo/\
3823  *        http://www.isthe.com/chongo/
3824  *
3825  * Share and Enjoy!     :-)
3826  */
3827
3828 typedef unsigned long long      mdb_hash_t;
3829 #define MDB_HASH_INIT ((mdb_hash_t)0xcbf29ce484222325ULL)
3830
3831 /** perform a 64 bit Fowler/Noll/Vo FNV-1a hash on a buffer
3832  * @param[in] val       value to hash
3833  * @param[in] hval      initial value for hash
3834  * @return 64 bit hash
3835  *
3836  * NOTE: To use the recommended 64 bit FNV-1a hash, use MDB_HASH_INIT as the
3837  *       hval arg on the first call.
3838  */
3839 static mdb_hash_t
3840 mdb_hash_val(MDB_val *val, mdb_hash_t hval)
3841 {
3842         unsigned char *s = (unsigned char *)val->mv_data;       /* unsigned string */
3843         unsigned char *end = s + val->mv_size;
3844         /*
3845          * FNV-1a hash each octet of the string
3846          */
3847         while (s < end) {
3848                 /* xor the bottom with the current octet */
3849                 hval ^= (mdb_hash_t)*s++;
3850
3851                 /* multiply by the 64 bit FNV magic prime mod 2^64 */
3852                 hval += (hval << 1) + (hval << 4) + (hval << 5) +
3853                         (hval << 7) + (hval << 8) + (hval << 40);
3854         }
3855         /* return our new hash value */
3856         return hval;
3857 }
3858
3859 /** Hash the string and output the encoded hash.
3860  * This uses modified RFC1924 Ascii85 encoding to accommodate systems with
3861  * very short name limits. We don't care about the encoding being reversible,
3862  * we just want to preserve as many bits of the input as possible in a
3863  * small printable string.
3864  * @param[in] str string to hash
3865  * @param[out] encbuf an array of 11 chars to hold the hash
3866  */
3867 static const char mdb_a85[]= "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
3868
3869 static void
3870 mdb_pack85(unsigned long l, char *out)
3871 {
3872         int i;
3873
3874         for (i=0; i<5; i++) {
3875                 *out++ = mdb_a85[l % 85];
3876                 l /= 85;
3877         }
3878 }
3879
3880 static void
3881 mdb_hash_enc(MDB_val *val, char *encbuf)
3882 {
3883         mdb_hash_t h = mdb_hash_val(val, MDB_HASH_INIT);
3884
3885         mdb_pack85(h, encbuf);
3886         mdb_pack85(h>>32, encbuf+5);
3887         encbuf[10] = '\0';
3888 }
3889 #endif
3890
3891 /** Open and/or initialize the lock region for the environment.
3892  * @param[in] env The MDB environment.
3893  * @param[in] lpath The pathname of the file used for the lock region.
3894  * @param[in] mode The Unix permissions for the file, if we create it.
3895  * @param[out] excl Resulting file lock type: -1 none, 0 shared, 1 exclusive
3896  * @param[in,out] excl In -1, out lock type: -1 none, 0 shared, 1 exclusive
3897  * @return 0 on success, non-zero on failure.
3898  */
3899 static int
3900 mdb_env_setup_locks(MDB_env *env, char *lpath, int mode, int *excl)
3901 {
3902 #ifdef _WIN32
3903 #       define MDB_ERRCODE_ROFS ERROR_WRITE_PROTECT
3904 #else
3905 #       define MDB_ERRCODE_ROFS EROFS
3906 #ifdef O_CLOEXEC        /* Linux: Open file and set FD_CLOEXEC atomically */
3907 #       define MDB_CLOEXEC              O_CLOEXEC
3908 #else
3909         int fdflags;
3910 #       define MDB_CLOEXEC              0
3911 #endif
3912 #endif
3913         int rc;
3914         off_t size, rsize;
3915
3916 #ifdef _WIN32
3917         env->me_lfd = CreateFile(lpath, GENERIC_READ|GENERIC_WRITE,
3918                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS,
3919                 FILE_ATTRIBUTE_NORMAL, NULL);
3920 #else
3921         env->me_lfd = open(lpath, O_RDWR|O_CREAT|MDB_CLOEXEC, mode);
3922 #endif
3923         if (env->me_lfd == INVALID_HANDLE_VALUE) {
3924                 rc = ErrCode();
3925                 if (rc == MDB_ERRCODE_ROFS && (env->me_flags & MDB_RDONLY)) {
3926                         return MDB_SUCCESS;
3927                 }
3928                 goto fail_errno;
3929         }
3930 #if ! ((MDB_CLOEXEC) || defined(_WIN32))
3931         /* Lose record locks when exec*() */
3932         if ((fdflags = fcntl(env->me_lfd, F_GETFD) | FD_CLOEXEC) >= 0)
3933                         fcntl(env->me_lfd, F_SETFD, fdflags);
3934 #endif
3935
3936         if (!(env->me_flags & MDB_NOTLS)) {
3937                 rc = pthread_key_create(&env->me_txkey, mdb_env_reader_dest);
3938                 if (rc)
3939                         goto fail;
3940                 env->me_flags |= MDB_ENV_TXKEY;
3941 #ifdef _WIN32
3942                 /* Windows TLS callbacks need help finding their TLS info. */
3943                 if (mdb_tls_nkeys >= MAX_TLS_KEYS) {
3944                         rc = MDB_TLS_FULL;
3945                         goto fail;
3946                 }
3947                 mdb_tls_keys[mdb_tls_nkeys++] = env->me_txkey;
3948 #endif
3949         }
3950
3951         /* Try to get exclusive lock. If we succeed, then
3952          * nobody is using the lock region and we should initialize it.
3953          */
3954         if ((rc = mdb_env_excl_lock(env, excl))) goto fail;
3955
3956 #ifdef _WIN32
3957         size = GetFileSize(env->me_lfd, NULL);
3958 #else
3959         size = lseek(env->me_lfd, 0, SEEK_END);
3960         if (size == -1) goto fail_errno;
3961 #endif
3962         rsize = (env->me_maxreaders-1) * sizeof(MDB_reader) + sizeof(MDB_txninfo);
3963         if (size < rsize && *excl > 0) {
3964 #ifdef _WIN32
3965                 if (SetFilePointer(env->me_lfd, rsize, NULL, FILE_BEGIN) != (DWORD)rsize
3966                         || !SetEndOfFile(env->me_lfd))
3967                         goto fail_errno;
3968 #else
3969                 if (ftruncate(env->me_lfd, rsize) != 0) goto fail_errno;
3970 #endif
3971         } else {
3972                 rsize = size;
3973                 size = rsize - sizeof(MDB_txninfo);
3974                 env->me_maxreaders = size/sizeof(MDB_reader) + 1;
3975         }
3976         {
3977 #ifdef _WIN32
3978                 HANDLE mh;
3979                 mh = CreateFileMapping(env->me_lfd, NULL, PAGE_READWRITE,
3980                         0, 0, NULL);
3981                 if (!mh) goto fail_errno;
3982                 env->me_txns = MapViewOfFileEx(mh, FILE_MAP_WRITE, 0, 0, rsize, NULL);
3983                 CloseHandle(mh);
3984                 if (!env->me_txns) goto fail_errno;
3985 #else
3986                 void *m = mmap(NULL, rsize, PROT_READ|PROT_WRITE, MAP_SHARED,
3987                         env->me_lfd, 0);
3988                 if (m == MAP_FAILED) goto fail_errno;
3989                 env->me_txns = m;
3990 #endif
3991         }
3992         if (*excl > 0) {
3993 #ifdef _WIN32
3994                 BY_HANDLE_FILE_INFORMATION stbuf;
3995                 struct {
3996                         DWORD volume;
3997                         DWORD nhigh;
3998                         DWORD nlow;
3999                 } idbuf;
4000                 MDB_val val;
4001                 char encbuf[11];
4002
4003                 if (!mdb_sec_inited) {
4004                         InitializeSecurityDescriptor(&mdb_null_sd,
4005                                 SECURITY_DESCRIPTOR_REVISION);
4006                         SetSecurityDescriptorDacl(&mdb_null_sd, TRUE, 0, FALSE);
4007                         mdb_all_sa.nLength = sizeof(SECURITY_ATTRIBUTES);
4008                         mdb_all_sa.bInheritHandle = FALSE;
4009                         mdb_all_sa.lpSecurityDescriptor = &mdb_null_sd;
4010                         mdb_sec_inited = 1;
4011                 }
4012                 if (!GetFileInformationByHandle(env->me_lfd, &stbuf)) goto fail_errno;
4013                 idbuf.volume = stbuf.dwVolumeSerialNumber;
4014                 idbuf.nhigh  = stbuf.nFileIndexHigh;
4015                 idbuf.nlow   = stbuf.nFileIndexLow;
4016                 val.mv_data = &idbuf;
4017                 val.mv_size = sizeof(idbuf);
4018                 mdb_hash_enc(&val, encbuf);
4019                 sprintf(env->me_txns->mti_rmname, "Global\\MDBr%s", encbuf);
4020                 sprintf(env->me_txns->mti_wmname, "Global\\MDBw%s", encbuf);
4021                 env->me_rmutex = CreateMutex(&mdb_all_sa, FALSE, env->me_txns->mti_rmname);
4022                 if (!env->me_rmutex) goto fail_errno;
4023                 env->me_wmutex = CreateMutex(&mdb_all_sa, FALSE, env->me_txns->mti_wmname);
4024                 if (!env->me_wmutex) goto fail_errno;
4025 #elif defined(MDB_USE_POSIX_SEM)
4026                 struct stat stbuf;
4027                 struct {
4028                         dev_t dev;
4029                         ino_t ino;
4030                 } idbuf;
4031                 MDB_val val;
4032                 char encbuf[11];
4033
4034 #if defined(__NetBSD__)
4035 #define MDB_SHORT_SEMNAMES      1       /* limited to 14 chars */
4036 #endif
4037                 if (fstat(env->me_lfd, &stbuf)) goto fail_errno;
4038                 idbuf.dev = stbuf.st_dev;
4039                 idbuf.ino = stbuf.st_ino;
4040                 val.mv_data = &idbuf;
4041                 val.mv_size = sizeof(idbuf);
4042                 mdb_hash_enc(&val, encbuf);
4043 #ifdef MDB_SHORT_SEMNAMES
4044                 encbuf[9] = '\0';       /* drop name from 15 chars to 14 chars */
4045 #endif
4046                 sprintf(env->me_txns->mti_rmname, "/MDBr%s", encbuf);
4047                 sprintf(env->me_txns->mti_wmname, "/MDBw%s", encbuf);
4048                 /* Clean up after a previous run, if needed:  Try to
4049                  * remove both semaphores before doing anything else.
4050                  */
4051                 sem_unlink(env->me_txns->mti_rmname);
4052                 sem_unlink(env->me_txns->mti_wmname);
4053                 env->me_rmutex = sem_open(env->me_txns->mti_rmname,
4054                         O_CREAT|O_EXCL, mode, 1);
4055                 if (env->me_rmutex == SEM_FAILED) goto fail_errno;
4056                 env->me_wmutex = sem_open(env->me_txns->mti_wmname,
4057                         O_CREAT|O_EXCL, mode, 1);
4058                 if (env->me_wmutex == SEM_FAILED) goto fail_errno;
4059 #else   /* MDB_USE_POSIX_SEM */
4060                 pthread_mutexattr_t mattr;
4061
4062                 if ((rc = pthread_mutexattr_init(&mattr))
4063                         || (rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED))
4064                         || (rc = pthread_mutex_init(&env->me_txns->mti_mutex, &mattr))
4065                         || (rc = pthread_mutex_init(&env->me_txns->mti_wmutex, &mattr)))
4066                         goto fail;
4067                 pthread_mutexattr_destroy(&mattr);
4068 #endif  /* _WIN32 || MDB_USE_POSIX_SEM */
4069
4070                 env->me_txns->mti_magic = MDB_MAGIC;
4071                 env->me_txns->mti_format = MDB_LOCK_FORMAT;
4072                 env->me_txns->mti_txnid = 0;
4073                 env->me_txns->mti_numreaders = 0;
4074
4075         } else {
4076                 if (env->me_txns->mti_magic != MDB_MAGIC) {
4077                         DPUTS("lock region has invalid magic");
4078                         rc = MDB_INVALID;
4079                         goto fail;
4080                 }
4081                 if (env->me_txns->mti_format != MDB_LOCK_FORMAT) {
4082                         DPRINTF(("lock region has format+version 0x%x, expected 0x%x",
4083                                 env->me_txns->mti_format, MDB_LOCK_FORMAT));
4084                         rc = MDB_VERSION_MISMATCH;
4085                         goto fail;
4086                 }
4087                 rc = ErrCode();
4088                 if (rc && rc != EACCES && rc != EAGAIN) {
4089                         goto fail;
4090                 }
4091 #ifdef _WIN32
4092                 env->me_rmutex = OpenMutex(SYNCHRONIZE, FALSE, env->me_txns->mti_rmname);
4093                 if (!env->me_rmutex) goto fail_errno;
4094                 env->me_wmutex = OpenMutex(SYNCHRONIZE, FALSE, env->me_txns->mti_wmname);
4095                 if (!env->me_wmutex) goto fail_errno;
4096 #elif defined(MDB_USE_POSIX_SEM)
4097                 env->me_rmutex = sem_open(env->me_txns->mti_rmname, 0);
4098                 if (env->me_rmutex == SEM_FAILED) goto fail_errno;
4099                 env->me_wmutex = sem_open(env->me_txns->mti_wmname, 0);
4100                 if (env->me_wmutex == SEM_FAILED) goto fail_errno;
4101 #endif
4102         }
4103         return MDB_SUCCESS;
4104
4105 fail_errno:
4106         rc = ErrCode();
4107 fail:
4108         return rc;
4109 }
4110
4111         /** The name of the lock file in the DB environment */
4112 #define LOCKNAME        "/lock.mdb"
4113         /** The name of the data file in the DB environment */
4114 #define DATANAME        "/data.mdb"
4115         /** The suffix of the lock file when no subdir is used */
4116 #define LOCKSUFF        "-lock"
4117         /** Only a subset of the @ref mdb_env flags can be changed
4118          *      at runtime. Changing other flags requires closing the
4119          *      environment and re-opening it with the new flags.
4120          */
4121 #define CHANGEABLE      (MDB_NOSYNC|MDB_NOMETASYNC|MDB_MAPASYNC|MDB_NOMEMINIT)
4122 #define CHANGELESS      (MDB_FIXEDMAP|MDB_NOSUBDIR|MDB_RDONLY|MDB_WRITEMAP| \
4123         MDB_NOTLS|MDB_NOLOCK|MDB_NORDAHEAD)
4124
4125 #if VALID_FLAGS & PERSISTENT_FLAGS & (CHANGEABLE|CHANGELESS)
4126 # error "Persistent DB flags & env flags overlap, but both go in mm_flags"
4127 #endif
4128
4129 int
4130 mdb_env_open(MDB_env *env, const char *path, unsigned int flags, mdb_mode_t mode)
4131 {
4132         int             oflags, rc, len, excl = -1;
4133         char *lpath, *dpath;
4134
4135         if (env->me_fd!=INVALID_HANDLE_VALUE || (flags & ~(CHANGEABLE|CHANGELESS)))
4136                 return EINVAL;
4137
4138         len = strlen(path);
4139         if (flags & MDB_NOSUBDIR) {
4140                 rc = len + sizeof(LOCKSUFF) + len + 1;
4141         } else {
4142                 rc = len + sizeof(LOCKNAME) + len + sizeof(DATANAME);
4143         }
4144         lpath = malloc(rc);
4145         if (!lpath)
4146                 return ENOMEM;
4147         if (flags & MDB_NOSUBDIR) {
4148                 dpath = lpath + len + sizeof(LOCKSUFF);
4149                 sprintf(lpath, "%s" LOCKSUFF, path);
4150                 strcpy(dpath, path);
4151         } else {
4152                 dpath = lpath + len + sizeof(LOCKNAME);
4153                 sprintf(lpath, "%s" LOCKNAME, path);
4154                 sprintf(dpath, "%s" DATANAME, path);
4155         }
4156
4157         rc = MDB_SUCCESS;
4158         flags |= env->me_flags;
4159         if (flags & MDB_RDONLY) {
4160                 /* silently ignore WRITEMAP when we're only getting read access */
4161                 flags &= ~MDB_WRITEMAP;
4162         } else {
4163                 if (!((env->me_free_pgs = mdb_midl_alloc(MDB_IDL_UM_MAX)) &&
4164                           (env->me_dirty_list = calloc(MDB_IDL_UM_SIZE, sizeof(MDB_ID2)))))
4165                         rc = ENOMEM;
4166         }
4167         env->me_flags = flags |= MDB_ENV_ACTIVE;
4168         if (rc)
4169                 goto leave;
4170
4171         env->me_path = strdup(path);
4172         env->me_dbxs = calloc(env->me_maxdbs, sizeof(MDB_dbx));
4173         env->me_dbflags = calloc(env->me_maxdbs, sizeof(uint16_t));
4174         if (!(env->me_dbxs && env->me_path && env->me_dbflags)) {
4175                 rc = ENOMEM;
4176                 goto leave;
4177         }
4178
4179         /* For RDONLY, get lockfile after we know datafile exists */
4180         if (!(flags & (MDB_RDONLY|MDB_NOLOCK))) {
4181                 rc = mdb_env_setup_locks(env, lpath, mode, &excl);
4182                 if (rc)
4183                         goto leave;
4184         }
4185
4186 #ifdef _WIN32
4187         if (F_ISSET(flags, MDB_RDONLY)) {
4188                 oflags = GENERIC_READ;
4189                 len = OPEN_EXISTING;
4190         } else {
4191                 oflags = GENERIC_READ|GENERIC_WRITE;
4192                 len = OPEN_ALWAYS;
4193         }
4194         mode = FILE_ATTRIBUTE_NORMAL;
4195         env->me_fd = CreateFile(dpath, oflags, FILE_SHARE_READ|FILE_SHARE_WRITE,
4196                 NULL, len, mode, NULL);
4197 #else
4198         if (F_ISSET(flags, MDB_RDONLY))
4199                 oflags = O_RDONLY;
4200         else
4201                 oflags = O_RDWR | O_CREAT;
4202
4203         env->me_fd = open(dpath, oflags, mode);
4204 #endif
4205         if (env->me_fd == INVALID_HANDLE_VALUE) {
4206                 rc = ErrCode();
4207                 goto leave;
4208         }
4209
4210         if ((flags & (MDB_RDONLY|MDB_NOLOCK)) == MDB_RDONLY) {
4211                 rc = mdb_env_setup_locks(env, lpath, mode, &excl);
4212                 if (rc)
4213                         goto leave;
4214         }
4215
4216         if ((rc = mdb_env_open2(env)) == MDB_SUCCESS) {
4217                 if (flags & (MDB_RDONLY|MDB_WRITEMAP)) {
4218                         env->me_mfd = env->me_fd;
4219                 } else {
4220                         /* Synchronous fd for meta writes. Needed even with
4221                          * MDB_NOSYNC/MDB_NOMETASYNC, in case these get reset.
4222                          */
4223 #ifdef _WIN32
4224                         len = OPEN_EXISTING;
4225                         env->me_mfd = CreateFile(dpath, oflags,
4226                                 FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, len,
4227                                 mode | FILE_FLAG_WRITE_THROUGH, NULL);
4228 #else
4229                         oflags &= ~O_CREAT;
4230                         env->me_mfd = open(dpath, oflags | MDB_DSYNC, mode);
4231 #endif
4232                         if (env->me_mfd == INVALID_HANDLE_VALUE) {
4233                                 rc = ErrCode();
4234                                 goto leave;
4235                         }
4236                 }
4237                 DPRINTF(("opened dbenv %p", (void *) env));
4238                 if (excl > 0) {
4239                         rc = mdb_env_share_locks(env, &excl);
4240                         if (rc)
4241                                 goto leave;
4242                 }
4243                 if (!((flags & MDB_RDONLY) ||
4244                           (env->me_pbuf = calloc(1, env->me_psize))))
4245                         rc = ENOMEM;
4246         }
4247
4248 leave:
4249         if (rc) {
4250                 mdb_env_close0(env, excl);
4251         }
4252         free(lpath);
4253         return rc;
4254 }
4255
4256 /** Destroy resources from mdb_env_open(), clear our readers & DBIs */
4257 static void
4258 mdb_env_close0(MDB_env *env, int excl)
4259 {
4260         int i;
4261
4262         if (!(env->me_flags & MDB_ENV_ACTIVE))
4263                 return;
4264
4265         /* Doing this here since me_dbxs may not exist during mdb_env_close */
4266         for (i = env->me_maxdbs; --i > MAIN_DBI; )
4267                 free(env->me_dbxs[i].md_name.mv_data);
4268
4269         free(env->me_pbuf);
4270         free(env->me_dbflags);
4271         free(env->me_dbxs);
4272         free(env->me_path);
4273         free(env->me_dirty_list);
4274         mdb_midl_free(env->me_free_pgs);
4275
4276         if (env->me_flags & MDB_ENV_TXKEY) {
4277                 pthread_key_delete(env->me_txkey);
4278 #ifdef _WIN32
4279                 /* Delete our key from the global list */
4280                 for (i=0; i<mdb_tls_nkeys; i++)
4281                         if (mdb_tls_keys[i] == env->me_txkey) {
4282                                 mdb_tls_keys[i] = mdb_tls_keys[mdb_tls_nkeys-1];
4283                                 mdb_tls_nkeys--;
4284                                 break;
4285                         }
4286 #endif
4287         }
4288
4289         if (env->me_map) {
4290                 munmap(env->me_map, env->me_mapsize);
4291         }
4292         if (env->me_mfd != env->me_fd && env->me_mfd != INVALID_HANDLE_VALUE)
4293                 (void) close(env->me_mfd);
4294         if (env->me_fd != INVALID_HANDLE_VALUE)
4295                 (void) close(env->me_fd);
4296         if (env->me_txns) {
4297                 MDB_PID_T pid = env->me_pid;
4298                 /* Clearing readers is done in this function because
4299                  * me_txkey with its destructor must be disabled first.
4300                  */
4301                 for (i = env->me_numreaders; --i >= 0; )
4302                         if (env->me_txns->mti_readers[i].mr_pid == pid)
4303                                 env->me_txns->mti_readers[i].mr_pid = 0;
4304 #ifdef _WIN32
4305                 if (env->me_rmutex) {
4306                         CloseHandle(env->me_rmutex);
4307                         if (env->me_wmutex) CloseHandle(env->me_wmutex);
4308                 }
4309                 /* Windows automatically destroys the mutexes when
4310                  * the last handle closes.
4311                  */
4312 #elif defined(MDB_USE_POSIX_SEM)
4313                 if (env->me_rmutex != SEM_FAILED) {
4314                         sem_close(env->me_rmutex);
4315                         if (env->me_wmutex != SEM_FAILED)
4316                                 sem_close(env->me_wmutex);
4317                         /* If we have the filelock:  If we are the
4318                          * only remaining user, clean up semaphores.
4319                          */
4320                         if (excl == 0)
4321                                 mdb_env_excl_lock(env, &excl);
4322                         if (excl > 0) {
4323                                 sem_unlink(env->me_txns->mti_rmname);
4324                                 sem_unlink(env->me_txns->mti_wmname);
4325                         }
4326                 }
4327 #endif
4328                 munmap((void *)env->me_txns, (env->me_maxreaders-1)*sizeof(MDB_reader)+sizeof(MDB_txninfo));
4329         }
4330         if (env->me_lfd != INVALID_HANDLE_VALUE) {
4331 #ifdef _WIN32
4332                 if (excl >= 0) {
4333                         /* Unlock the lockfile.  Windows would have unlocked it
4334                          * after closing anyway, but not necessarily at once.
4335                          */
4336                         UnlockFile(env->me_lfd, 0, 0, 1, 0);
4337                 }
4338 #endif
4339                 (void) close(env->me_lfd);
4340         }
4341
4342         env->me_flags &= ~(MDB_ENV_ACTIVE|MDB_ENV_TXKEY);
4343 }
4344
4345 int
4346 mdb_env_copyfd(MDB_env *env, HANDLE fd)
4347 {
4348         MDB_txn *txn = NULL;
4349         int rc;
4350         size_t wsize;
4351         char *ptr;
4352 #ifdef _WIN32
4353         DWORD len, w2;
4354 #define DO_WRITE(rc, fd, ptr, w2, len)  rc = WriteFile(fd, ptr, w2, &len, NULL)
4355 #else
4356         ssize_t len;
4357         size_t w2;
4358 #define DO_WRITE(rc, fd, ptr, w2, len)  len = write(fd, ptr, w2); rc = (len >= 0)
4359 #endif
4360
4361         /* Do the lock/unlock of the reader mutex before starting the
4362          * write txn.  Otherwise other read txns could block writers.
4363          */
4364         rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
4365         if (rc)
4366                 return rc;
4367
4368         if (env->me_txns) {
4369                 /* We must start the actual read txn after blocking writers */
4370                 mdb_txn_reset0(txn, "reset-stage1");
4371
4372                 /* Temporarily block writers until we snapshot the meta pages */
4373                 LOCK_MUTEX_W(env);
4374
4375                 rc = mdb_txn_renew0(txn);
4376                 if (rc) {
4377                         UNLOCK_MUTEX_W(env);
4378                         goto leave;
4379                 }
4380         }
4381
4382         wsize = env->me_psize * 2;
4383         ptr = env->me_map;
4384         w2 = wsize;
4385         while (w2 > 0) {
4386                 DO_WRITE(rc, fd, ptr, w2, len);
4387                 if (!rc) {
4388                         rc = ErrCode();
4389                         break;
4390                 } else if (len > 0) {
4391                         rc = MDB_SUCCESS;
4392                         ptr += len;
4393                         w2 -= len;
4394                         continue;
4395                 } else {
4396                         /* Non-blocking or async handles are not supported */
4397                         rc = EIO;
4398                         break;
4399                 }
4400         }
4401         if (env->me_txns)
4402                 UNLOCK_MUTEX_W(env);
4403
4404         if (rc)
4405                 goto leave;
4406
4407         wsize = txn->mt_next_pgno * env->me_psize - wsize;
4408         while (wsize > 0) {
4409                 if (wsize > MAX_WRITE)
4410                         w2 = MAX_WRITE;
4411                 else
4412                         w2 = wsize;
4413                 DO_WRITE(rc, fd, ptr, w2, len);
4414                 if (!rc) {
4415                         rc = ErrCode();
4416                         break;
4417                 } else if (len > 0) {
4418                         rc = MDB_SUCCESS;
4419                         ptr += len;
4420                         wsize -= len;
4421                         continue;
4422                 } else {
4423                         rc = EIO;
4424                         break;
4425                 }
4426         }
4427
4428 leave:
4429         mdb_txn_abort(txn);
4430         return rc;
4431 }
4432
4433 int
4434 mdb_env_copy(MDB_env *env, const char *path)
4435 {
4436         int rc, len;
4437         char *lpath;
4438         HANDLE newfd = INVALID_HANDLE_VALUE;
4439
4440         if (env->me_flags & MDB_NOSUBDIR) {
4441                 lpath = (char *)path;
4442         } else {
4443                 len = strlen(path);
4444                 len += sizeof(DATANAME);
4445                 lpath = malloc(len);
4446                 if (!lpath)
4447                         return ENOMEM;
4448                 sprintf(lpath, "%s" DATANAME, path);
4449         }
4450
4451         /* The destination path must exist, but the destination file must not.
4452          * We don't want the OS to cache the writes, since the source data is
4453          * already in the OS cache.
4454          */
4455 #ifdef _WIN32
4456         newfd = CreateFile(lpath, GENERIC_WRITE, 0, NULL, CREATE_NEW,
4457                                 FILE_FLAG_NO_BUFFERING|FILE_FLAG_WRITE_THROUGH, NULL);
4458 #else
4459         newfd = open(lpath, O_WRONLY|O_CREAT|O_EXCL, 0666);
4460 #endif
4461         if (newfd == INVALID_HANDLE_VALUE) {
4462                 rc = ErrCode();
4463                 goto leave;
4464         }
4465
4466 #ifdef O_DIRECT
4467         /* Set O_DIRECT if the file system supports it */
4468         if ((rc = fcntl(newfd, F_GETFL)) != -1)
4469                 (void) fcntl(newfd, F_SETFL, rc | O_DIRECT);
4470 #endif
4471 #ifdef F_NOCACHE        /* __APPLE__ */
4472         rc = fcntl(newfd, F_NOCACHE, 1);
4473         if (rc) {
4474                 rc = ErrCode();
4475                 goto leave;
4476         }
4477 #endif
4478
4479         rc = mdb_env_copyfd(env, newfd);
4480
4481 leave:
4482         if (!(env->me_flags & MDB_NOSUBDIR))
4483                 free(lpath);
4484         if (newfd != INVALID_HANDLE_VALUE)
4485                 if (close(newfd) < 0 && rc == MDB_SUCCESS)
4486                         rc = ErrCode();
4487
4488         return rc;
4489 }
4490
4491 void
4492 mdb_env_close(MDB_env *env)
4493 {
4494         MDB_page *dp;
4495
4496         if (env == NULL)
4497                 return;
4498
4499         VGMEMP_DESTROY(env);
4500         while ((dp = env->me_dpages) != NULL) {
4501                 VGMEMP_DEFINED(&dp->mp_next, sizeof(dp->mp_next));
4502                 env->me_dpages = dp->mp_next;
4503                 free(dp);
4504         }
4505
4506         mdb_env_close0(env, 0);
4507         free(env);
4508 }
4509
4510 /** Compare two items pointing at aligned size_t's */
4511 static int
4512 mdb_cmp_long(const MDB_val *a, const MDB_val *b)
4513 {
4514         return (*(size_t *)a->mv_data < *(size_t *)b->mv_data) ? -1 :
4515                 *(size_t *)a->mv_data > *(size_t *)b->mv_data;
4516 }
4517
4518 /** Compare two items pointing at aligned unsigned int's */
4519 static int
4520 mdb_cmp_int(const MDB_val *a, const MDB_val *b)
4521 {
4522         return (*(unsigned int *)a->mv_data < *(unsigned int *)b->mv_data) ? -1 :
4523                 *(unsigned int *)a->mv_data > *(unsigned int *)b->mv_data;
4524 }
4525
4526 /** Compare two items pointing at unsigned ints of unknown alignment.
4527  *      Nodes and keys are guaranteed to be 2-byte aligned.
4528  */
4529 static int
4530 mdb_cmp_cint(const MDB_val *a, const MDB_val *b)
4531 {
4532 #if BYTE_ORDER == LITTLE_ENDIAN
4533         unsigned short *u, *c;
4534         int x;
4535
4536         u = (unsigned short *) ((char *) a->mv_data + a->mv_size);
4537         c = (unsigned short *) ((char *) b->mv_data + a->mv_size);
4538         do {
4539                 x = *--u - *--c;
4540         } while(!x && u > (unsigned short *)a->mv_data);
4541         return x;
4542 #else
4543         return memcmp(a->mv_data, b->mv_data, a->mv_size);
4544 #endif
4545 }
4546
4547 /** Compare two items pointing at size_t's of unknown alignment. */
4548 #ifdef MISALIGNED_OK
4549 # define mdb_cmp_clong mdb_cmp_long
4550 #else
4551 # define mdb_cmp_clong mdb_cmp_cint
4552 #endif
4553
4554 /** Compare two items lexically */
4555 static int
4556 mdb_cmp_memn(const MDB_val *a, const MDB_val *b)
4557 {
4558         int diff;
4559         ssize_t len_diff;
4560         unsigned int len;
4561
4562         len = a->mv_size;
4563         len_diff = (ssize_t) a->mv_size - (ssize_t) b->mv_size;
4564         if (len_diff > 0) {
4565                 len = b->mv_size;
4566                 len_diff = 1;
4567         }
4568
4569         diff = memcmp(a->mv_data, b->mv_data, len);
4570         return diff ? diff : len_diff<0 ? -1 : len_diff;
4571 }
4572
4573 /** Compare two items in reverse byte order */
4574 static int
4575 mdb_cmp_memnr(const MDB_val *a, const MDB_val *b)
4576 {
4577         const unsigned char     *p1, *p2, *p1_lim;
4578         ssize_t len_diff;
4579         int diff;
4580
4581         p1_lim = (const unsigned char *)a->mv_data;
4582         p1 = (const unsigned char *)a->mv_data + a->mv_size;
4583         p2 = (const unsigned char *)b->mv_data + b->mv_size;
4584
4585         len_diff = (ssize_t) a->mv_size - (ssize_t) b->mv_size;
4586         if (len_diff > 0) {
4587                 p1_lim += len_diff;
4588                 len_diff = 1;
4589         }
4590
4591         while (p1 > p1_lim) {
4592                 diff = *--p1 - *--p2;
4593                 if (diff)
4594                         return diff;
4595         }
4596         return len_diff<0 ? -1 : len_diff;
4597 }
4598
4599 /** Search for key within a page, using binary search.
4600  * Returns the smallest entry larger or equal to the key.
4601  * If exactp is non-null, stores whether the found entry was an exact match
4602  * in *exactp (1 or 0).
4603  * Updates the cursor index with the index of the found entry.
4604  * If no entry larger or equal to the key is found, returns NULL.
4605  */
4606 static MDB_node *
4607 mdb_node_search(MDB_cursor *mc, MDB_val *key, int *exactp)
4608 {
4609         unsigned int     i = 0, nkeys;
4610         int              low, high;
4611         int              rc = 0;
4612         MDB_page *mp = mc->mc_pg[mc->mc_top];
4613         MDB_node        *node = NULL;
4614         MDB_val  nodekey;
4615         MDB_cmp_func *cmp;
4616         DKBUF;
4617
4618         nkeys = NUMKEYS(mp);
4619
4620         DPRINTF(("searching %u keys in %s %spage %"Z"u",
4621             nkeys, IS_LEAF(mp) ? "leaf" : "branch", IS_SUBP(mp) ? "sub-" : "",
4622             mdb_dbg_pgno(mp)));
4623
4624         low = IS_LEAF(mp) ? 0 : 1;
4625         high = nkeys - 1;
4626         cmp = mc->mc_dbx->md_cmp;
4627
4628         /* Branch pages have no data, so if using integer keys,
4629          * alignment is guaranteed. Use faster mdb_cmp_int.
4630          */
4631         if (cmp == mdb_cmp_cint && IS_BRANCH(mp)) {
4632                 if (NODEPTR(mp, 1)->mn_ksize == sizeof(size_t))
4633                         cmp = mdb_cmp_long;
4634                 else
4635                         cmp = mdb_cmp_int;
4636         }
4637
4638         if (IS_LEAF2(mp)) {
4639                 nodekey.mv_size = mc->mc_db->md_pad;
4640                 node = NODEPTR(mp, 0);  /* fake */
4641                 while (low <= high) {
4642                         i = (low + high) >> 1;
4643                         nodekey.mv_data = LEAF2KEY(mp, i, nodekey.mv_size);
4644                         rc = cmp(key, &nodekey);
4645                         DPRINTF(("found leaf index %u [%s], rc = %i",
4646                             i, DKEY(&nodekey), rc));
4647                         if (rc == 0)
4648                                 break;
4649                         if (rc > 0)
4650                                 low = i + 1;
4651                         else
4652                                 high = i - 1;
4653                 }
4654         } else {
4655                 while (low <= high) {
4656                         i = (low + high) >> 1;
4657
4658                         node = NODEPTR(mp, i);
4659                         nodekey.mv_size = NODEKSZ(node);
4660                         nodekey.mv_data = NODEKEY(node);
4661
4662                         rc = cmp(key, &nodekey);
4663 #if MDB_DEBUG
4664                         if (IS_LEAF(mp))
4665                                 DPRINTF(("found leaf index %u [%s], rc = %i",
4666                                     i, DKEY(&nodekey), rc));
4667                         else
4668                                 DPRINTF(("found branch index %u [%s -> %"Z"u], rc = %i",
4669                                     i, DKEY(&nodekey), NODEPGNO(node), rc));
4670 #endif
4671                         if (rc == 0)
4672                                 break;
4673                         if (rc > 0)
4674                                 low = i + 1;
4675                         else
4676                                 high = i - 1;
4677                 }
4678         }
4679
4680         if (rc > 0) {   /* Found entry is less than the key. */
4681                 i++;    /* Skip to get the smallest entry larger than key. */
4682                 if (!IS_LEAF2(mp))
4683                         node = NODEPTR(mp, i);
4684         }
4685         if (exactp)
4686                 *exactp = (rc == 0 && nkeys > 0);
4687         /* store the key index */
4688         mc->mc_ki[mc->mc_top] = i;
4689         if (i >= nkeys)
4690                 /* There is no entry larger or equal to the key. */
4691                 return NULL;
4692
4693         /* nodeptr is fake for LEAF2 */
4694         return node;
4695 }
4696
4697 #if 0
4698 static void
4699 mdb_cursor_adjust(MDB_cursor *mc, func)
4700 {
4701         MDB_cursor *m2;
4702
4703         for (m2 = mc->mc_txn->mt_cursors[mc->mc_dbi]; m2; m2=m2->mc_next) {
4704                 if (m2->mc_pg[m2->mc_top] == mc->mc_pg[mc->mc_top]) {
4705                         func(mc, m2);
4706                 }
4707         }
4708 }
4709 #endif
4710
4711 /** Pop a page off the top of the cursor's stack. */
4712 static void
4713 mdb_cursor_pop(MDB_cursor *mc)
4714 {
4715         if (mc->mc_snum) {
4716 #if MDB_DEBUG
4717                 MDB_page        *top = mc->mc_pg[mc->mc_top];
4718 #endif
4719                 mc->mc_snum--;
4720                 if (mc->mc_snum)
4721                         mc->mc_top--;
4722
4723                 DPRINTF(("popped page %"Z"u off db %d cursor %p", top->mp_pgno,
4724                         DDBI(mc), (void *) mc));
4725         }
4726 }
4727
4728 /** Push a page onto the top of the cursor's stack. */
4729 static int
4730 mdb_cursor_push(MDB_cursor *mc, MDB_page *mp)
4731 {
4732         DPRINTF(("pushing page %"Z"u on db %d cursor %p", mp->mp_pgno,
4733                 DDBI(mc), (void *) mc));
4734
4735         if (mc->mc_snum >= CURSOR_STACK) {
4736                 mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
4737                 return MDB_CURSOR_FULL;
4738         }
4739
4740         mc->mc_top = mc->mc_snum++;
4741         mc->mc_pg[mc->mc_top] = mp;
4742         mc->mc_ki[mc->mc_top] = 0;
4743
4744         return MDB_SUCCESS;
4745 }
4746
4747 /** Find the address of the page corresponding to a given page number.
4748  * @param[in] txn the transaction for this access.
4749  * @param[in] pgno the page number for the page to retrieve.
4750  * @param[out] ret address of a pointer where the page's address will be stored.
4751  * @param[out] lvl dirty_list inheritance level of found page. 1=current txn, 0=mapped page.
4752  * @return 0 on success, non-zero on failure.
4753  */
4754 static int
4755 mdb_page_get(MDB_txn *txn, pgno_t pgno, MDB_page **ret, int *lvl)
4756 {
4757         MDB_env *env = txn->mt_env;
4758         MDB_page *p = NULL;
4759         int level;
4760
4761         if (!((txn->mt_flags & MDB_TXN_RDONLY) | (env->me_flags & MDB_WRITEMAP))) {
4762                 MDB_txn *tx2 = txn;
4763                 level = 1;
4764                 do {
4765                         MDB_ID2L dl = tx2->mt_u.dirty_list;
4766                         unsigned x;
4767                         /* Spilled pages were dirtied in this txn and flushed
4768                          * because the dirty list got full. Bring this page
4769                          * back in from the map (but don't unspill it here,
4770                          * leave that unless page_touch happens again).
4771                          */
4772                         if (tx2->mt_spill_pgs) {
4773                                 MDB_ID pn = pgno << 1;
4774                                 x = mdb_midl_search(tx2->mt_spill_pgs, pn);
4775                                 if (x <= tx2->mt_spill_pgs[0] && tx2->mt_spill_pgs[x] == pn) {
4776                                         p = (MDB_page *)(env->me_map + env->me_psize * pgno);
4777                                         goto done;
4778                                 }
4779                         }
4780                         if (dl[0].mid) {
4781                                 unsigned x = mdb_mid2l_search(dl, pgno);
4782                                 if (x <= dl[0].mid && dl[x].mid == pgno) {
4783                                         p = dl[x].mptr;
4784                                         goto done;
4785                                 }
4786                         }
4787                         level++;
4788                 } while ((tx2 = tx2->mt_parent) != NULL);
4789         }
4790
4791         if (pgno < txn->mt_next_pgno) {
4792                 level = 0;
4793                 p = (MDB_page *)(env->me_map + env->me_psize * pgno);
4794         } else {
4795                 DPRINTF(("page %"Z"u not found", pgno));
4796                 txn->mt_flags |= MDB_TXN_ERROR;
4797                 return MDB_PAGE_NOTFOUND;
4798         }
4799
4800 done:
4801         *ret = p;
4802         if (lvl)
4803                 *lvl = level;
4804         return MDB_SUCCESS;
4805 }
4806
4807 /** Finish #mdb_page_search() / #mdb_page_search_lowest().
4808  *      The cursor is at the root page, set up the rest of it.
4809  */
4810 static int
4811 mdb_page_search_root(MDB_cursor *mc, MDB_val *key, int flags)
4812 {
4813         MDB_page        *mp = mc->mc_pg[mc->mc_top];
4814         int rc;
4815         DKBUF;
4816
4817         while (IS_BRANCH(mp)) {
4818                 MDB_node        *node;
4819                 indx_t          i;
4820
4821                 DPRINTF(("branch page %"Z"u has %u keys", mp->mp_pgno, NUMKEYS(mp)));
4822                 mdb_cassert(mc, NUMKEYS(mp) > 1);
4823                 DPRINTF(("found index 0 to page %"Z"u", NODEPGNO(NODEPTR(mp, 0))));
4824
4825                 if (flags & (MDB_PS_FIRST|MDB_PS_LAST)) {
4826                         i = 0;
4827                         if (flags & MDB_PS_LAST)
4828                                 i = NUMKEYS(mp) - 1;
4829                 } else {
4830                         int      exact;
4831                         node = mdb_node_search(mc, key, &exact);
4832                         if (node == NULL)
4833                                 i = NUMKEYS(mp) - 1;
4834                         else {
4835                                 i = mc->mc_ki[mc->mc_top];
4836                                 if (!exact) {
4837                                         mdb_cassert(mc, i > 0);
4838                                         i--;
4839                                 }
4840                         }
4841                         DPRINTF(("following index %u for key [%s]", i, DKEY(key)));
4842                 }
4843
4844                 mdb_cassert(mc, i < NUMKEYS(mp));
4845                 node = NODEPTR(mp, i);
4846
4847                 if ((rc = mdb_page_get(mc->mc_txn, NODEPGNO(node), &mp, NULL)) != 0)
4848                         return rc;
4849
4850                 mc->mc_ki[mc->mc_top] = i;
4851                 if ((rc = mdb_cursor_push(mc, mp)))
4852                         return rc;
4853
4854                 if (flags & MDB_PS_MODIFY) {
4855                         if ((rc = mdb_page_touch(mc)) != 0)
4856                                 return rc;
4857                         mp = mc->mc_pg[mc->mc_top];
4858                 }
4859         }
4860
4861         if (!IS_LEAF(mp)) {
4862                 DPRINTF(("internal error, index points to a %02X page!?",
4863                     mp->mp_flags));
4864                 mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
4865                 return MDB_CORRUPTED;
4866         }
4867
4868         DPRINTF(("found leaf page %"Z"u for key [%s]", mp->mp_pgno,
4869             key ? DKEY(key) : "null"));
4870         mc->mc_flags |= C_INITIALIZED;
4871         mc->mc_flags &= ~C_EOF;
4872
4873         return MDB_SUCCESS;
4874 }
4875
4876 /** Search for the lowest key under the current branch page.
4877  * This just bypasses a NUMKEYS check in the current page
4878  * before calling mdb_page_search_root(), because the callers
4879  * are all in situations where the current page is known to
4880  * be underfilled.
4881  */
4882 static int
4883 mdb_page_search_lowest(MDB_cursor *mc)
4884 {
4885         MDB_page        *mp = mc->mc_pg[mc->mc_top];
4886         MDB_node        *node = NODEPTR(mp, 0);
4887         int rc;
4888
4889         if ((rc = mdb_page_get(mc->mc_txn, NODEPGNO(node), &mp, NULL)) != 0)
4890                 return rc;
4891
4892         mc->mc_ki[mc->mc_top] = 0;
4893         if ((rc = mdb_cursor_push(mc, mp)))
4894                 return rc;
4895         return mdb_page_search_root(mc, NULL, MDB_PS_FIRST);
4896 }
4897
4898 /** Search for the page a given key should be in.
4899  * Push it and its parent pages on the cursor stack.
4900  * @param[in,out] mc the cursor for this operation.
4901  * @param[in] key the key to search for, or NULL for first/last page.
4902  * @param[in] flags If MDB_PS_MODIFY is set, visited pages in the DB
4903  *   are touched (updated with new page numbers).
4904  *   If MDB_PS_FIRST or MDB_PS_LAST is set, find first or last leaf.
4905  *   This is used by #mdb_cursor_first() and #mdb_cursor_last().
4906  *   If MDB_PS_ROOTONLY set, just fetch root node, no further lookups.
4907  * @return 0 on success, non-zero on failure.
4908  */
4909 static int
4910 mdb_page_search(MDB_cursor *mc, MDB_val *key, int flags)
4911 {
4912         int              rc;
4913         pgno_t           root;
4914
4915         /* Make sure the txn is still viable, then find the root from
4916          * the txn's db table and set it as the root of the cursor's stack.
4917          */
4918         if (F_ISSET(mc->mc_txn->mt_flags, MDB_TXN_ERROR)) {
4919                 DPUTS("transaction has failed, must abort");
4920                 return MDB_BAD_TXN;
4921         } else {
4922                 /* Make sure we're using an up-to-date root */
4923                 if (*mc->mc_dbflag & DB_STALE) {
4924                                 MDB_cursor mc2;
4925                                 mdb_cursor_init(&mc2, mc->mc_txn, MAIN_DBI, NULL);
4926                                 rc = mdb_page_search(&mc2, &mc->mc_dbx->md_name, 0);
4927                                 if (rc)
4928                                         return rc;
4929                                 {
4930                                         MDB_val data;
4931                                         int exact = 0;
4932                                         uint16_t flags;
4933                                         MDB_node *leaf = mdb_node_search(&mc2,
4934                                                 &mc->mc_dbx->md_name, &exact);
4935                                         if (!exact)
4936                                                 return MDB_NOTFOUND;
4937                                         rc = mdb_node_read(mc->mc_txn, leaf, &data);
4938                                         if (rc)
4939                                                 return rc;
4940                                         memcpy(&flags, ((char *) data.mv_data + offsetof(MDB_db, md_flags)),
4941                                                 sizeof(uint16_t));
4942                                         /* The txn may not know this DBI, or another process may
4943                                          * have dropped and recreated the DB with other flags.
4944                                          */
4945                                         if ((mc->mc_db->md_flags & PERSISTENT_FLAGS) != flags)
4946                                                 return MDB_INCOMPATIBLE;
4947                                         memcpy(mc->mc_db, data.mv_data, sizeof(MDB_db));
4948                                 }
4949                                 *mc->mc_dbflag &= ~DB_STALE;
4950                 }
4951                 root = mc->mc_db->md_root;
4952
4953                 if (root == P_INVALID) {                /* Tree is empty. */
4954                         DPUTS("tree is empty");
4955                         return MDB_NOTFOUND;
4956                 }
4957         }
4958
4959         mdb_cassert(mc, root > 1);
4960         if (!mc->mc_pg[0] || mc->mc_pg[0]->mp_pgno != root)
4961                 if ((rc = mdb_page_get(mc->mc_txn, root, &mc->mc_pg[0], NULL)) != 0)
4962                         return rc;
4963
4964         mc->mc_snum = 1;
4965         mc->mc_top = 0;
4966
4967         DPRINTF(("db %d root page %"Z"u has flags 0x%X",
4968                 DDBI(mc), root, mc->mc_pg[0]->mp_flags));
4969
4970         if (flags & MDB_PS_MODIFY) {
4971                 if ((rc = mdb_page_touch(mc)))
4972                         return rc;
4973         }
4974
4975         if (flags & MDB_PS_ROOTONLY)
4976                 return MDB_SUCCESS;
4977
4978         return mdb_page_search_root(mc, key, flags);
4979 }
4980
4981 static int
4982 mdb_ovpage_free(MDB_cursor *mc, MDB_page *mp)
4983 {
4984         MDB_txn *txn = mc->mc_txn;
4985         pgno_t pg = mp->mp_pgno;
4986         unsigned x = 0, ovpages = mp->mp_pages;
4987         MDB_env *env = txn->mt_env;
4988         MDB_IDL sl = txn->mt_spill_pgs;
4989         MDB_ID pn = pg << 1;
4990         int rc;
4991
4992         DPRINTF(("free ov page %"Z"u (%d)", pg, ovpages));
4993         /* If the page is dirty or on the spill list we just acquired it,
4994          * so we should give it back to our current free list, if any.
4995          * Otherwise put it onto the list of pages we freed in this txn.
4996          *
4997          * Won't create me_pghead: me_pglast must be inited along with it.
4998          * Unsupported in nested txns: They would need to hide the page
4999          * range in ancestor txns' dirty and spilled lists.
5000          */
5001         if (env->me_pghead &&
5002                 !txn->mt_parent &&
5003                 ((mp->mp_flags & P_DIRTY) ||
5004                  (sl && (x = mdb_midl_search(sl, pn)) <= sl[0] && sl[x] == pn)))
5005         {
5006                 unsigned i, j;
5007                 pgno_t *mop;
5008                 MDB_ID2 *dl, ix, iy;
5009                 rc = mdb_midl_need(&env->me_pghead, ovpages);
5010                 if (rc)
5011                         return rc;
5012                 if (!(mp->mp_flags & P_DIRTY)) {
5013                         /* This page is no longer spilled */
5014                         if (x == sl[0])
5015                                 sl[0]--;
5016                         else
5017                                 sl[x] |= 1;
5018                         goto release;
5019                 }
5020                 /* Remove from dirty list */
5021                 dl = txn->mt_u.dirty_list;
5022                 x = dl[0].mid--;
5023                 for (ix = dl[x]; ix.mptr != mp; ix = iy) {
5024                         if (x > 1) {
5025                                 x--;
5026                                 iy = dl[x];
5027                                 dl[x] = ix;
5028                         } else {
5029                                 mdb_cassert(mc, x > 1);
5030                                 j = ++(dl[0].mid);
5031                                 dl[j] = ix;             /* Unsorted. OK when MDB_TXN_ERROR. */
5032                                 txn->mt_flags |= MDB_TXN_ERROR;
5033                                 return MDB_CORRUPTED;
5034                         }
5035                 }
5036                 if (!(env->me_flags & MDB_WRITEMAP))
5037                         mdb_dpage_free(env, mp);
5038 release:
5039                 /* Insert in me_pghead */
5040                 mop = env->me_pghead;
5041                 j = mop[0] + ovpages;
5042                 for (i = mop[0]; i && mop[i] < pg; i--)
5043                         mop[j--] = mop[i];
5044                 while (j>i)
5045                         mop[j--] = pg++;
5046                 mop[0] += ovpages;
5047         } else {
5048                 rc = mdb_midl_append_range(&txn->mt_free_pgs, pg, ovpages);
5049                 if (rc)
5050                         return rc;
5051         }
5052         mc->mc_db->md_overflow_pages -= ovpages;
5053         return 0;
5054 }
5055
5056 /** Return the data associated with a given node.
5057  * @param[in] txn The transaction for this operation.
5058  * @param[in] leaf The node being read.
5059  * @param[out] data Updated to point to the node's data.
5060  * @return 0 on success, non-zero on failure.
5061  */
5062 static int
5063 mdb_node_read(MDB_txn *txn, MDB_node *leaf, MDB_val *data)
5064 {
5065         MDB_page        *omp;           /* overflow page */
5066         pgno_t           pgno;
5067         int rc;
5068
5069         if (!F_ISSET(leaf->mn_flags, F_BIGDATA)) {
5070                 data->mv_size = NODEDSZ(leaf);
5071                 data->mv_data = NODEDATA(leaf);
5072                 return MDB_SUCCESS;
5073         }
5074
5075         /* Read overflow data.
5076          */
5077         data->mv_size = NODEDSZ(leaf);
5078         memcpy(&pgno, NODEDATA(leaf), sizeof(pgno));
5079         if ((rc = mdb_page_get(txn, pgno, &omp, NULL)) != 0) {
5080                 DPRINTF(("read overflow page %"Z"u failed", pgno));
5081                 return rc;
5082         }
5083         data->mv_data = METADATA(omp);
5084
5085         return MDB_SUCCESS;
5086 }
5087
5088 int
5089 mdb_get(MDB_txn *txn, MDB_dbi dbi,
5090     MDB_val *key, MDB_val *data)
5091 {
5092         MDB_cursor      mc;
5093         MDB_xcursor     mx;
5094         int exact = 0;
5095         DKBUF;
5096
5097         DPRINTF(("===> get db %u key [%s]", dbi, DKEY(key)));
5098
5099         if (!key || !data || dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
5100                 return EINVAL;
5101
5102         if (txn->mt_flags & MDB_TXN_ERROR)
5103                 return MDB_BAD_TXN;
5104
5105         mdb_cursor_init(&mc, txn, dbi, &mx);
5106         return mdb_cursor_set(&mc, key, data, MDB_SET, &exact);
5107 }
5108
5109 /** Find a sibling for a page.
5110  * Replaces the page at the top of the cursor's stack with the
5111  * specified sibling, if one exists.
5112  * @param[in] mc The cursor for this operation.
5113  * @param[in] move_right Non-zero if the right sibling is requested,
5114  * otherwise the left sibling.
5115  * @return 0 on success, non-zero on failure.
5116  */
5117 static int
5118 mdb_cursor_sibling(MDB_cursor *mc, int move_right)
5119 {
5120         int              rc;
5121         MDB_node        *indx;
5122         MDB_page        *mp;
5123
5124         if (mc->mc_snum < 2) {
5125                 return MDB_NOTFOUND;            /* root has no siblings */
5126         }
5127
5128         mdb_cursor_pop(mc);
5129         DPRINTF(("parent page is page %"Z"u, index %u",
5130                 mc->mc_pg[mc->mc_top]->mp_pgno, mc->mc_ki[mc->mc_top]));
5131
5132         if (move_right ? (mc->mc_ki[mc->mc_top] + 1u >= NUMKEYS(mc->mc_pg[mc->mc_top]))
5133                        : (mc->mc_ki[mc->mc_top] == 0)) {
5134                 DPRINTF(("no more keys left, moving to %s sibling",
5135                     move_right ? "right" : "left"));
5136                 if ((rc = mdb_cursor_sibling(mc, move_right)) != MDB_SUCCESS) {
5137                         /* undo cursor_pop before returning */
5138                         mc->mc_top++;
5139                         mc->mc_snum++;
5140                         return rc;
5141                 }
5142         } else {
5143                 if (move_right)
5144                         mc->mc_ki[mc->mc_top]++;
5145                 else
5146                         mc->mc_ki[mc->mc_top]--;
5147                 DPRINTF(("just moving to %s index key %u",
5148                     move_right ? "right" : "left", mc->mc_ki[mc->mc_top]));
5149         }
5150         mdb_cassert(mc, IS_BRANCH(mc->mc_pg[mc->mc_top]));
5151
5152         indx = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
5153         if ((rc = mdb_page_get(mc->mc_txn, NODEPGNO(indx), &mp, NULL)) != 0) {
5154                 /* mc will be inconsistent if caller does mc_snum++ as above */
5155                 mc->mc_flags &= ~(C_INITIALIZED|C_EOF);
5156                 return rc;
5157         }
5158
5159         mdb_cursor_push(mc, mp);
5160         if (!move_right)
5161                 mc->mc_ki[mc->mc_top] = NUMKEYS(mp)-1;
5162
5163         return MDB_SUCCESS;
5164 }
5165
5166 /** Move the cursor to the next data item. */
5167 static int
5168 mdb_cursor_next(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op)
5169 {
5170         MDB_page        *mp;
5171         MDB_node        *leaf;
5172         int rc;
5173
5174         if (mc->mc_flags & C_EOF) {
5175                 return MDB_NOTFOUND;
5176         }
5177
5178         mdb_cassert(mc, mc->mc_flags & C_INITIALIZED);
5179
5180         mp = mc->mc_pg[mc->mc_top];
5181
5182         if (mc->mc_db->md_flags & MDB_DUPSORT) {
5183                 leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5184                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5185                         if (op == MDB_NEXT || op == MDB_NEXT_DUP) {
5186                                 rc = mdb_cursor_next(&mc->mc_xcursor->mx_cursor, data, NULL, MDB_NEXT);
5187                                 if (op != MDB_NEXT || rc != MDB_NOTFOUND) {
5188                                         if (rc == MDB_SUCCESS)
5189                                                 MDB_GET_KEY(leaf, key);
5190                                         return rc;
5191                                 }
5192                         }
5193                 } else {
5194                         mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5195                         if (op == MDB_NEXT_DUP)
5196                                 return MDB_NOTFOUND;
5197                 }
5198         }
5199
5200         DPRINTF(("cursor_next: top page is %"Z"u in cursor %p",
5201                 mdb_dbg_pgno(mp), (void *) mc));
5202         if (mc->mc_flags & C_DEL)
5203                 goto skip;
5204
5205         if (mc->mc_ki[mc->mc_top] + 1u >= NUMKEYS(mp)) {
5206                 DPUTS("=====> move to next sibling page");
5207                 if ((rc = mdb_cursor_sibling(mc, 1)) != MDB_SUCCESS) {
5208                         mc->mc_flags |= C_EOF;
5209                         return rc;
5210                 }
5211                 mp = mc->mc_pg[mc->mc_top];
5212                 DPRINTF(("next page is %"Z"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
5213         } else
5214                 mc->mc_ki[mc->mc_top]++;
5215
5216 skip:
5217         DPRINTF(("==> cursor points to page %"Z"u with %u keys, key index %u",
5218             mdb_dbg_pgno(mp), NUMKEYS(mp), mc->mc_ki[mc->mc_top]));
5219
5220         if (IS_LEAF2(mp)) {
5221                 key->mv_size = mc->mc_db->md_pad;
5222                 key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
5223                 return MDB_SUCCESS;
5224         }
5225
5226         mdb_cassert(mc, IS_LEAF(mp));
5227         leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5228
5229         if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5230                 mdb_xcursor_init1(mc, leaf);
5231         }
5232         if (data) {
5233                 if ((rc = mdb_node_read(mc->mc_txn, leaf, data)) != MDB_SUCCESS)
5234                         return rc;
5235
5236                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5237                         rc = mdb_cursor_first(&mc->mc_xcursor->mx_cursor, data, NULL);
5238                         if (rc != MDB_SUCCESS)
5239                                 return rc;
5240                 }
5241         }
5242
5243         MDB_GET_KEY(leaf, key);
5244         return MDB_SUCCESS;
5245 }
5246
5247 /** Move the cursor to the previous data item. */
5248 static int
5249 mdb_cursor_prev(MDB_cursor *mc, MDB_val *key, MDB_val *data, MDB_cursor_op op)
5250 {
5251         MDB_page        *mp;
5252         MDB_node        *leaf;
5253         int rc;
5254
5255         mdb_cassert(mc, mc->mc_flags & C_INITIALIZED);
5256
5257         mp = mc->mc_pg[mc->mc_top];
5258
5259         if (mc->mc_db->md_flags & MDB_DUPSORT) {
5260                 leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5261                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5262                         if (op == MDB_PREV || op == MDB_PREV_DUP) {
5263                                 rc = mdb_cursor_prev(&mc->mc_xcursor->mx_cursor, data, NULL, MDB_PREV);
5264                                 if (op != MDB_PREV || rc != MDB_NOTFOUND) {
5265                                         if (rc == MDB_SUCCESS)
5266                                                 MDB_GET_KEY(leaf, key);
5267                                         return rc;
5268                                 }
5269                         } else {
5270                                 mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5271                                 if (op == MDB_PREV_DUP)
5272                                         return MDB_NOTFOUND;
5273                         }
5274                 }
5275         }
5276
5277         DPRINTF(("cursor_prev: top page is %"Z"u in cursor %p",
5278                 mdb_dbg_pgno(mp), (void *) mc));
5279
5280         if (mc->mc_ki[mc->mc_top] == 0)  {
5281                 DPUTS("=====> move to prev sibling page");
5282                 if ((rc = mdb_cursor_sibling(mc, 0)) != MDB_SUCCESS) {
5283                         return rc;
5284                 }
5285                 mp = mc->mc_pg[mc->mc_top];
5286                 mc->mc_ki[mc->mc_top] = NUMKEYS(mp) - 1;
5287                 DPRINTF(("prev page is %"Z"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
5288         } else
5289                 mc->mc_ki[mc->mc_top]--;
5290
5291         mc->mc_flags &= ~C_EOF;
5292
5293         DPRINTF(("==> cursor points to page %"Z"u with %u keys, key index %u",
5294             mdb_dbg_pgno(mp), NUMKEYS(mp), mc->mc_ki[mc->mc_top]));
5295
5296         if (IS_LEAF2(mp)) {
5297                 key->mv_size = mc->mc_db->md_pad;
5298                 key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
5299                 return MDB_SUCCESS;
5300         }
5301
5302         mdb_cassert(mc, IS_LEAF(mp));
5303         leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5304
5305         if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5306                 mdb_xcursor_init1(mc, leaf);
5307         }
5308         if (data) {
5309                 if ((rc = mdb_node_read(mc->mc_txn, leaf, data)) != MDB_SUCCESS)
5310                         return rc;
5311
5312                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5313                         rc = mdb_cursor_last(&mc->mc_xcursor->mx_cursor, data, NULL);
5314                         if (rc != MDB_SUCCESS)
5315                                 return rc;
5316                 }
5317         }
5318
5319         MDB_GET_KEY(leaf, key);
5320         return MDB_SUCCESS;
5321 }
5322
5323 /** Set the cursor on a specific data item. */
5324 static int
5325 mdb_cursor_set(MDB_cursor *mc, MDB_val *key, MDB_val *data,
5326     MDB_cursor_op op, int *exactp)
5327 {
5328         int              rc;
5329         MDB_page        *mp;
5330         MDB_node        *leaf = NULL;
5331         DKBUF;
5332
5333         if (key->mv_size == 0)
5334                 return MDB_BAD_VALSIZE;
5335
5336         if (mc->mc_xcursor)
5337                 mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5338
5339         /* See if we're already on the right page */
5340         if (mc->mc_flags & C_INITIALIZED) {
5341                 MDB_val nodekey;
5342
5343                 mp = mc->mc_pg[mc->mc_top];
5344                 if (!NUMKEYS(mp)) {
5345                         mc->mc_ki[mc->mc_top] = 0;
5346                         return MDB_NOTFOUND;
5347                 }
5348                 if (mp->mp_flags & P_LEAF2) {
5349                         nodekey.mv_size = mc->mc_db->md_pad;
5350                         nodekey.mv_data = LEAF2KEY(mp, 0, nodekey.mv_size);
5351                 } else {
5352                         leaf = NODEPTR(mp, 0);
5353                         MDB_GET_KEY2(leaf, nodekey);
5354                 }
5355                 rc = mc->mc_dbx->md_cmp(key, &nodekey);
5356                 if (rc == 0) {
5357                         /* Probably happens rarely, but first node on the page
5358                          * was the one we wanted.
5359                          */
5360                         mc->mc_ki[mc->mc_top] = 0;
5361                         if (exactp)
5362                                 *exactp = 1;
5363                         goto set1;
5364                 }
5365                 if (rc > 0) {
5366                         unsigned int i;
5367                         unsigned int nkeys = NUMKEYS(mp);
5368                         if (nkeys > 1) {
5369                                 if (mp->mp_flags & P_LEAF2) {
5370                                         nodekey.mv_data = LEAF2KEY(mp,
5371                                                  nkeys-1, nodekey.mv_size);
5372                                 } else {
5373                                         leaf = NODEPTR(mp, nkeys-1);
5374                                         MDB_GET_KEY2(leaf, nodekey);
5375                                 }
5376                                 rc = mc->mc_dbx->md_cmp(key, &nodekey);
5377                                 if (rc == 0) {
5378                                         /* last node was the one we wanted */
5379                                         mc->mc_ki[mc->mc_top] = nkeys-1;
5380                                         if (exactp)
5381                                                 *exactp = 1;
5382                                         goto set1;
5383                                 }
5384                                 if (rc < 0) {
5385                                         if (mc->mc_ki[mc->mc_top] < NUMKEYS(mp)) {
5386                                                 /* This is definitely the right page, skip search_page */
5387                                                 if (mp->mp_flags & P_LEAF2) {
5388                                                         nodekey.mv_data = LEAF2KEY(mp,
5389                                                                  mc->mc_ki[mc->mc_top], nodekey.mv_size);
5390                                                 } else {
5391                                                         leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5392                                                         MDB_GET_KEY2(leaf, nodekey);
5393                                                 }
5394                                                 rc = mc->mc_dbx->md_cmp(key, &nodekey);
5395                                                 if (rc == 0) {
5396                                                         /* current node was the one we wanted */
5397                                                         if (exactp)
5398                                                                 *exactp = 1;
5399                                                         goto set1;
5400                                                 }
5401                                         }
5402                                         rc = 0;
5403                                         goto set2;
5404                                 }
5405                         }
5406                         /* If any parents have right-sibs, search.
5407                          * Otherwise, there's nothing further.
5408                          */
5409                         for (i=0; i<mc->mc_top; i++)
5410                                 if (mc->mc_ki[i] <
5411                                         NUMKEYS(mc->mc_pg[i])-1)
5412                                         break;
5413                         if (i == mc->mc_top) {
5414                                 /* There are no other pages */
5415                                 mc->mc_ki[mc->mc_top] = nkeys;
5416                                 return MDB_NOTFOUND;
5417                         }
5418                 }
5419                 if (!mc->mc_top) {
5420                         /* There are no other pages */
5421                         mc->mc_ki[mc->mc_top] = 0;
5422                         if (op == MDB_SET_RANGE) {
5423                                 rc = 0;
5424                                 goto set1;
5425                         } else
5426                                 return MDB_NOTFOUND;
5427                 }
5428         }
5429
5430         rc = mdb_page_search(mc, key, 0);
5431         if (rc != MDB_SUCCESS)
5432                 return rc;
5433
5434         mp = mc->mc_pg[mc->mc_top];
5435         mdb_cassert(mc, IS_LEAF(mp));
5436
5437 set2:
5438         leaf = mdb_node_search(mc, key, exactp);
5439         if (exactp != NULL && !*exactp) {
5440                 /* MDB_SET specified and not an exact match. */
5441                 return MDB_NOTFOUND;
5442         }
5443
5444         if (leaf == NULL) {
5445                 DPUTS("===> inexact leaf not found, goto sibling");
5446                 if ((rc = mdb_cursor_sibling(mc, 1)) != MDB_SUCCESS)
5447                         return rc;              /* no entries matched */
5448                 mp = mc->mc_pg[mc->mc_top];
5449                 mdb_cassert(mc, IS_LEAF(mp));
5450                 leaf = NODEPTR(mp, 0);
5451         }
5452
5453 set1:
5454         mc->mc_flags |= C_INITIALIZED;
5455         mc->mc_flags &= ~C_EOF;
5456
5457         if (IS_LEAF2(mp)) {
5458                 key->mv_size = mc->mc_db->md_pad;
5459                 key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
5460                 return MDB_SUCCESS;
5461         }
5462
5463         if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5464                 mdb_xcursor_init1(mc, leaf);
5465         }
5466         if (data) {
5467                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5468                         if (op == MDB_SET || op == MDB_SET_KEY || op == MDB_SET_RANGE) {
5469                                 rc = mdb_cursor_first(&mc->mc_xcursor->mx_cursor, data, NULL);
5470                         } else {
5471                                 int ex2, *ex2p;
5472                                 if (op == MDB_GET_BOTH) {
5473                                         ex2p = &ex2;
5474                                         ex2 = 0;
5475                                 } else {
5476                                         ex2p = NULL;
5477                                 }
5478                                 rc = mdb_cursor_set(&mc->mc_xcursor->mx_cursor, data, NULL, MDB_SET_RANGE, ex2p);
5479                                 if (rc != MDB_SUCCESS)
5480                                         return rc;
5481                         }
5482                 } else if (op == MDB_GET_BOTH || op == MDB_GET_BOTH_RANGE) {
5483                         MDB_val d2;
5484                         if ((rc = mdb_node_read(mc->mc_txn, leaf, &d2)) != MDB_SUCCESS)
5485                                 return rc;
5486                         rc = mc->mc_dbx->md_dcmp(data, &d2);
5487                         if (rc) {
5488                                 if (op == MDB_GET_BOTH || rc > 0)
5489                                         return MDB_NOTFOUND;
5490                                 rc = 0;
5491                                 *data = d2;
5492                         }
5493
5494                 } else {
5495                         if (mc->mc_xcursor)
5496                                 mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5497                         if ((rc = mdb_node_read(mc->mc_txn, leaf, data)) != MDB_SUCCESS)
5498                                 return rc;
5499                 }
5500         }
5501
5502         /* The key already matches in all other cases */
5503         if (op == MDB_SET_RANGE || op == MDB_SET_KEY)
5504                 MDB_GET_KEY(leaf, key);
5505         DPRINTF(("==> cursor placed on key [%s]", DKEY(key)));
5506
5507         return rc;
5508 }
5509
5510 /** Move the cursor to the first item in the database. */
5511 static int
5512 mdb_cursor_first(MDB_cursor *mc, MDB_val *key, MDB_val *data)
5513 {
5514         int              rc;
5515         MDB_node        *leaf;
5516
5517         if (mc->mc_xcursor)
5518                 mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5519
5520         if (!(mc->mc_flags & C_INITIALIZED) || mc->mc_top) {
5521                 rc = mdb_page_search(mc, NULL, MDB_PS_FIRST);
5522                 if (rc != MDB_SUCCESS)
5523                         return rc;
5524         }
5525         mdb_cassert(mc, IS_LEAF(mc->mc_pg[mc->mc_top]));
5526
5527         leaf = NODEPTR(mc->mc_pg[mc->mc_top], 0);
5528         mc->mc_flags |= C_INITIALIZED;
5529         mc->mc_flags &= ~C_EOF;
5530
5531         mc->mc_ki[mc->mc_top] = 0;
5532
5533         if (IS_LEAF2(mc->mc_pg[mc->mc_top])) {
5534                 key->mv_size = mc->mc_db->md_pad;
5535                 key->mv_data = LEAF2KEY(mc->mc_pg[mc->mc_top], 0, key->mv_size);
5536                 return MDB_SUCCESS;
5537         }
5538
5539         if (data) {
5540                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5541                         mdb_xcursor_init1(mc, leaf);
5542                         rc = mdb_cursor_first(&mc->mc_xcursor->mx_cursor, data, NULL);
5543                         if (rc)
5544                                 return rc;
5545                 } else {
5546                         if ((rc = mdb_node_read(mc->mc_txn, leaf, data)) != MDB_SUCCESS)
5547                                 return rc;
5548                 }
5549         }
5550         MDB_GET_KEY(leaf, key);
5551         return MDB_SUCCESS;
5552 }
5553
5554 /** Move the cursor to the last item in the database. */
5555 static int
5556 mdb_cursor_last(MDB_cursor *mc, MDB_val *key, MDB_val *data)
5557 {
5558         int              rc;
5559         MDB_node        *leaf;
5560
5561         if (mc->mc_xcursor)
5562                 mc->mc_xcursor->mx_cursor.mc_flags &= ~(C_INITIALIZED|C_EOF);
5563
5564         if (!(mc->mc_flags & C_EOF)) {
5565
5566                 if (!(mc->mc_flags & C_INITIALIZED) || mc->mc_top) {
5567                         rc = mdb_page_search(mc, NULL, MDB_PS_LAST);
5568                         if (rc != MDB_SUCCESS)
5569                                 return rc;
5570                 }
5571                 mdb_cassert(mc, IS_LEAF(mc->mc_pg[mc->mc_top]));
5572
5573         }
5574         mc->mc_ki[mc->mc_top] = NUMKEYS(mc->mc_pg[mc->mc_top]) - 1;
5575         mc->mc_flags |= C_INITIALIZED|C_EOF;
5576         leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
5577
5578         if (IS_LEAF2(mc->mc_pg[mc->mc_top])) {
5579                 key->mv_size = mc->mc_db->md_pad;
5580                 key->mv_data = LEAF2KEY(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top], key->mv_size);
5581                 return MDB_SUCCESS;
5582         }
5583
5584         if (data) {
5585                 if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5586                         mdb_xcursor_init1(mc, leaf);
5587                         rc = mdb_cursor_last(&mc->mc_xcursor->mx_cursor, data, NULL);
5588                         if (rc)
5589                                 return rc;
5590                 } else {
5591                         if ((rc = mdb_node_read(mc->mc_txn, leaf, data)) != MDB_SUCCESS)
5592                                 return rc;
5593                 }
5594         }
5595
5596         MDB_GET_KEY(leaf, key);
5597         return MDB_SUCCESS;
5598 }
5599
5600 int
5601 mdb_cursor_get(MDB_cursor *mc, MDB_val *key, MDB_val *data,
5602     MDB_cursor_op op)
5603 {
5604         int              rc;
5605         int              exact = 0;
5606         int              (*mfunc)(MDB_cursor *mc, MDB_val *key, MDB_val *data);
5607
5608         if (mc == NULL)
5609                 return EINVAL;
5610
5611         if (mc->mc_txn->mt_flags & MDB_TXN_ERROR)
5612                 return MDB_BAD_TXN;
5613
5614         switch (op) {
5615         case MDB_GET_CURRENT:
5616                 if (!(mc->mc_flags & C_INITIALIZED)) {
5617                         rc = EINVAL;
5618                 } else {
5619                         MDB_page *mp = mc->mc_pg[mc->mc_top];
5620                         int nkeys = NUMKEYS(mp);
5621                         if (!nkeys || mc->mc_ki[mc->mc_top] >= nkeys) {
5622                                 mc->mc_ki[mc->mc_top] = nkeys;
5623                                 rc = MDB_NOTFOUND;
5624                                 break;
5625                         }
5626                         rc = MDB_SUCCESS;
5627                         if (IS_LEAF2(mp)) {
5628                                 key->mv_size = mc->mc_db->md_pad;
5629                                 key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
5630                         } else {
5631                                 MDB_node *leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
5632                                 MDB_GET_KEY(leaf, key);
5633                                 if (data) {
5634                                         if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5635                                                 if (mc->mc_flags & C_DEL)
5636                                                         mdb_xcursor_init1(mc, leaf);
5637                                                 rc = mdb_cursor_get(&mc->mc_xcursor->mx_cursor, data, NULL, MDB_GET_CURRENT);
5638                                         } else {
5639                                                 rc = mdb_node_read(mc->mc_txn, leaf, data);
5640                                         }
5641                                 }
5642                         }
5643                 }
5644                 break;
5645         case MDB_GET_BOTH:
5646         case MDB_GET_BOTH_RANGE:
5647                 if (data == NULL) {
5648                         rc = EINVAL;
5649                         break;
5650                 }
5651                 if (mc->mc_xcursor == NULL) {
5652                         rc = MDB_INCOMPATIBLE;
5653                         break;
5654                 }
5655                 /* FALLTHRU */
5656         case MDB_SET:
5657         case MDB_SET_KEY:
5658         case MDB_SET_RANGE:
5659                 if (key == NULL) {
5660                         rc = EINVAL;
5661                 } else {
5662                         rc = mdb_cursor_set(mc, key, data, op,
5663                                 op == MDB_SET_RANGE ? NULL : &exact);
5664                 }
5665                 break;
5666         case MDB_GET_MULTIPLE:
5667                 if (data == NULL || !(mc->mc_flags & C_INITIALIZED)) {
5668                         rc = EINVAL;
5669                         break;
5670                 }
5671                 if (!(mc->mc_db->md_flags & MDB_DUPFIXED)) {
5672                         rc = MDB_INCOMPATIBLE;
5673                         break;
5674                 }
5675                 rc = MDB_SUCCESS;
5676                 if (!(mc->mc_xcursor->mx_cursor.mc_flags & C_INITIALIZED) ||
5677                         (mc->mc_xcursor->mx_cursor.mc_flags & C_EOF))
5678                         break;
5679                 goto fetchm;
5680         case MDB_NEXT_MULTIPLE:
5681                 if (data == NULL) {
5682                         rc = EINVAL;
5683                         break;
5684                 }
5685                 if (!(mc->mc_db->md_flags & MDB_DUPFIXED)) {
5686                         rc = MDB_INCOMPATIBLE;
5687                         break;
5688                 }
5689                 if (!(mc->mc_flags & C_INITIALIZED))
5690                         rc = mdb_cursor_first(mc, key, data);
5691                 else
5692                         rc = mdb_cursor_next(mc, key, data, MDB_NEXT_DUP);
5693                 if (rc == MDB_SUCCESS) {
5694                         if (mc->mc_xcursor->mx_cursor.mc_flags & C_INITIALIZED) {
5695                                 MDB_cursor *mx;
5696 fetchm:
5697                                 mx = &mc->mc_xcursor->mx_cursor;
5698                                 data->mv_size = NUMKEYS(mx->mc_pg[mx->mc_top]) *
5699                                         mx->mc_db->md_pad;
5700                                 data->mv_data = METADATA(mx->mc_pg[mx->mc_top]);
5701                                 mx->mc_ki[mx->mc_top] = NUMKEYS(mx->mc_pg[mx->mc_top])-1;
5702                         } else {
5703                                 rc = MDB_NOTFOUND;
5704                         }
5705                 }
5706                 break;
5707         case MDB_NEXT:
5708         case MDB_NEXT_DUP:
5709         case MDB_NEXT_NODUP:
5710                 if (!(mc->mc_flags & C_INITIALIZED))
5711                         rc = mdb_cursor_first(mc, key, data);
5712                 else
5713                         rc = mdb_cursor_next(mc, key, data, op);
5714                 break;
5715         case MDB_PREV:
5716         case MDB_PREV_DUP:
5717         case MDB_PREV_NODUP:
5718                 if (!(mc->mc_flags & C_INITIALIZED)) {
5719                         rc = mdb_cursor_last(mc, key, data);
5720                         if (rc)
5721                                 break;
5722                         mc->mc_flags |= C_INITIALIZED;
5723                         mc->mc_ki[mc->mc_top]++;
5724                 }
5725                 rc = mdb_cursor_prev(mc, key, data, op);
5726                 break;
5727         case MDB_FIRST:
5728                 rc = mdb_cursor_first(mc, key, data);
5729                 break;
5730         case MDB_FIRST_DUP:
5731                 mfunc = mdb_cursor_first;
5732         mmove:
5733                 if (data == NULL || !(mc->mc_flags & C_INITIALIZED)) {
5734                         rc = EINVAL;
5735                         break;
5736                 }
5737                 if (mc->mc_xcursor == NULL) {
5738                         rc = MDB_INCOMPATIBLE;
5739                         break;
5740                 }
5741                 if (!(mc->mc_xcursor->mx_cursor.mc_flags & C_INITIALIZED)) {
5742                         rc = EINVAL;
5743                         break;
5744                 }
5745                 rc = mfunc(&mc->mc_xcursor->mx_cursor, data, NULL);
5746                 break;
5747         case MDB_LAST:
5748                 rc = mdb_cursor_last(mc, key, data);
5749                 break;
5750         case MDB_LAST_DUP:
5751                 mfunc = mdb_cursor_last;
5752                 goto mmove;
5753         default:
5754                 DPRINTF(("unhandled/unimplemented cursor operation %u", op));
5755                 rc = EINVAL;
5756                 break;
5757         }
5758
5759         if (mc->mc_flags & C_DEL)
5760                 mc->mc_flags ^= C_DEL;
5761
5762         return rc;
5763 }
5764
5765 /** Touch all the pages in the cursor stack. Set mc_top.
5766  *      Makes sure all the pages are writable, before attempting a write operation.
5767  * @param[in] mc The cursor to operate on.
5768  */
5769 static int
5770 mdb_cursor_touch(MDB_cursor *mc)
5771 {
5772         int rc = MDB_SUCCESS;
5773
5774         if (mc->mc_dbi > MAIN_DBI && !(*mc->mc_dbflag & DB_DIRTY)) {
5775                 MDB_cursor mc2;
5776                 MDB_xcursor mcx;
5777                 mdb_cursor_init(&mc2, mc->mc_txn, MAIN_DBI, &mcx);
5778                 rc = mdb_page_search(&mc2, &mc->mc_dbx->md_name, MDB_PS_MODIFY);
5779                 if (rc)
5780                          return rc;
5781                 *mc->mc_dbflag |= DB_DIRTY;
5782         }
5783         mc->mc_top = 0;
5784         if (mc->mc_snum) {
5785                 do {
5786                         rc = mdb_page_touch(mc);
5787                 } while (!rc && ++(mc->mc_top) < mc->mc_snum);
5788                 mc->mc_top = mc->mc_snum-1;
5789         }
5790         return rc;
5791 }
5792
5793 /** Do not spill pages to disk if txn is getting full, may fail instead */
5794 #define MDB_NOSPILL     0x8000
5795
5796 int
5797 mdb_cursor_put(MDB_cursor *mc, MDB_val *key, MDB_val *data,
5798     unsigned int flags)
5799 {
5800         enum { MDB_NO_ROOT = MDB_LAST_ERRCODE+10 }; /* internal code */
5801         MDB_env         *env;
5802         MDB_node        *leaf = NULL;
5803         MDB_page        *fp, *mp;
5804         uint16_t        fp_flags;
5805         MDB_val         xdata, *rdata, dkey, olddata;
5806         MDB_db dummy;
5807         int do_sub = 0, insert_key, insert_data;
5808         unsigned int mcount = 0, dcount = 0, nospill;
5809         size_t nsize;
5810         int rc, rc2;
5811         unsigned int nflags;
5812         DKBUF;
5813
5814         if (mc == NULL || key == NULL)
5815                 return EINVAL;
5816
5817         env = mc->mc_txn->mt_env;
5818
5819         /* Check this first so counter will always be zero on any
5820          * early failures.
5821          */
5822         if (flags & MDB_MULTIPLE) {
5823                 dcount = data[1].mv_size;
5824                 data[1].mv_size = 0;
5825                 if (!F_ISSET(mc->mc_db->md_flags, MDB_DUPFIXED))
5826                         return MDB_INCOMPATIBLE;
5827         }
5828
5829         nospill = flags & MDB_NOSPILL;
5830         flags &= ~MDB_NOSPILL;
5831
5832         if (mc->mc_txn->mt_flags & (MDB_TXN_RDONLY|MDB_TXN_ERROR))
5833                 return (mc->mc_txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
5834
5835         if (key->mv_size-1 >= ENV_MAXKEY(env))
5836                 return MDB_BAD_VALSIZE;
5837
5838 #if SIZE_MAX > MAXDATASIZE
5839         if (data->mv_size > ((mc->mc_db->md_flags & MDB_DUPSORT) ? ENV_MAXKEY(env) : MAXDATASIZE))
5840                 return MDB_BAD_VALSIZE;
5841 #else
5842         if ((mc->mc_db->md_flags & MDB_DUPSORT) && data->mv_size > ENV_MAXKEY(env))
5843                 return MDB_BAD_VALSIZE;
5844 #endif
5845
5846         DPRINTF(("==> put db %d key [%s], size %"Z"u, data size %"Z"u",
5847                 DDBI(mc), DKEY(key), key ? key->mv_size : 0, data->mv_size));
5848
5849         dkey.mv_size = 0;
5850
5851         if (flags == MDB_CURRENT) {
5852                 if (!(mc->mc_flags & C_INITIALIZED))
5853                         return EINVAL;
5854                 rc = MDB_SUCCESS;
5855         } else if (mc->mc_db->md_root == P_INVALID) {
5856                 /* new database, cursor has nothing to point to */
5857                 mc->mc_snum = 0;
5858                 mc->mc_top = 0;
5859                 mc->mc_flags &= ~C_INITIALIZED;
5860                 rc = MDB_NO_ROOT;
5861         } else {
5862                 int exact = 0;
5863                 MDB_val d2;
5864                 if (flags & MDB_APPEND) {
5865                         MDB_val k2;
5866                         rc = mdb_cursor_last(mc, &k2, &d2);
5867                         if (rc == 0) {
5868                                 rc = mc->mc_dbx->md_cmp(key, &k2);
5869                                 if (rc > 0) {
5870                                         rc = MDB_NOTFOUND;
5871                                         mc->mc_ki[mc->mc_top]++;
5872                                 } else {
5873                                         /* new key is <= last key */
5874                                         rc = MDB_KEYEXIST;
5875                                 }
5876                         }
5877                 } else {
5878                         rc = mdb_cursor_set(mc, key, &d2, MDB_SET, &exact);
5879                 }
5880                 if ((flags & MDB_NOOVERWRITE) && rc == 0) {
5881                         DPRINTF(("duplicate key [%s]", DKEY(key)));
5882                         *data = d2;
5883                         return MDB_KEYEXIST;
5884                 }
5885                 if (rc && rc != MDB_NOTFOUND)
5886                         return rc;
5887         }
5888
5889         if (mc->mc_flags & C_DEL)
5890                 mc->mc_flags ^= C_DEL;
5891
5892         /* Cursor is positioned, check for room in the dirty list */
5893         if (!nospill) {
5894                 if (flags & MDB_MULTIPLE) {
5895                         rdata = &xdata;
5896                         xdata.mv_size = data->mv_size * dcount;
5897                 } else {
5898                         rdata = data;
5899                 }
5900                 if ((rc2 = mdb_page_spill(mc, key, rdata)))
5901                         return rc2;
5902         }
5903
5904         if (rc == MDB_NO_ROOT) {
5905                 MDB_page *np;
5906                 /* new database, write a root leaf page */
5907                 DPUTS("allocating new root leaf page");
5908                 if ((rc2 = mdb_page_new(mc, P_LEAF, 1, &np))) {
5909                         return rc2;
5910                 }
5911                 mdb_cursor_push(mc, np);
5912                 mc->mc_db->md_root = np->mp_pgno;
5913                 mc->mc_db->md_depth++;
5914                 *mc->mc_dbflag |= DB_DIRTY;
5915                 if ((mc->mc_db->md_flags & (MDB_DUPSORT|MDB_DUPFIXED))
5916                         == MDB_DUPFIXED)
5917                         np->mp_flags |= P_LEAF2;
5918                 mc->mc_flags |= C_INITIALIZED;
5919         } else {
5920                 /* make sure all cursor pages are writable */
5921                 rc2 = mdb_cursor_touch(mc);
5922                 if (rc2)
5923                         return rc2;
5924         }
5925
5926         insert_key = insert_data = rc;
5927         if (insert_key) {
5928                 /* The key does not exist */
5929                 DPRINTF(("inserting key at index %i", mc->mc_ki[mc->mc_top]));
5930                 if ((mc->mc_db->md_flags & MDB_DUPSORT) &&
5931                         LEAFSIZE(key, data) > env->me_nodemax)
5932                 {
5933                         /* Too big for a node, insert in sub-DB */
5934                         fp_flags = P_LEAF|P_DIRTY;
5935                         fp = env->me_pbuf;
5936                         fp->mp_pad = data->mv_size; /* used if MDB_DUPFIXED */
5937                         fp->mp_lower = fp->mp_upper = olddata.mv_size = PAGEHDRSZ;
5938                         goto prep_subDB;
5939                 }
5940         } else {
5941                 /* there's only a key anyway, so this is a no-op */
5942                 if (IS_LEAF2(mc->mc_pg[mc->mc_top])) {
5943                         unsigned int ksize = mc->mc_db->md_pad;
5944                         if (key->mv_size != ksize)
5945                                 return MDB_BAD_VALSIZE;
5946                         if (flags == MDB_CURRENT) {
5947                                 char *ptr = LEAF2KEY(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top], ksize);
5948                                 memcpy(ptr, key->mv_data, ksize);
5949                         }
5950                         return MDB_SUCCESS;
5951                 }
5952
5953 more:
5954                 leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
5955                 olddata.mv_size = NODEDSZ(leaf);
5956                 olddata.mv_data = NODEDATA(leaf);
5957
5958                 /* DB has dups? */
5959                 if (F_ISSET(mc->mc_db->md_flags, MDB_DUPSORT)) {
5960                         /* Prepare (sub-)page/sub-DB to accept the new item,
5961                          * if needed.  fp: old sub-page or a header faking
5962                          * it.  mp: new (sub-)page.  offset: growth in page
5963                          * size.  xdata: node data with new page or DB.
5964                          */
5965                         unsigned        i, offset = 0;
5966                         mp = fp = xdata.mv_data = env->me_pbuf;
5967                         mp->mp_pgno = mc->mc_pg[mc->mc_top]->mp_pgno;
5968
5969                         /* Was a single item before, must convert now */
5970                         if (!F_ISSET(leaf->mn_flags, F_DUPDATA)) {
5971                                 /* Just overwrite the current item */
5972                                 if (flags == MDB_CURRENT)
5973                                         goto current;
5974
5975 #if UINT_MAX < SIZE_MAX
5976                                 if (mc->mc_dbx->md_dcmp == mdb_cmp_int && olddata.mv_size == sizeof(size_t))
5977                                         mc->mc_dbx->md_dcmp = mdb_cmp_clong;
5978 #endif
5979                                 /* if data matches, skip it */
5980                                 if (!mc->mc_dbx->md_dcmp(data, &olddata)) {
5981                                         if (flags & MDB_NODUPDATA)
5982                                                 return MDB_KEYEXIST;
5983                                         rc = MDB_SUCCESS;
5984                                         goto next_sub;
5985                                 }
5986
5987                                 /* Back up original data item */
5988                                 dkey.mv_size = olddata.mv_size;
5989                                 dkey.mv_data = memcpy(fp+1, olddata.mv_data, olddata.mv_size);
5990
5991                                 /* Make sub-page header for the dup items, with dummy body */
5992                                 fp->mp_flags = P_LEAF|P_DIRTY|P_SUBP;
5993                                 fp->mp_lower = PAGEHDRSZ;
5994                                 xdata.mv_size = PAGEHDRSZ + dkey.mv_size + data->mv_size;
5995                                 if (mc->mc_db->md_flags & MDB_DUPFIXED) {
5996                                         fp->mp_flags |= P_LEAF2;
5997                                         fp->mp_pad = data->mv_size;
5998                                         xdata.mv_size += 2 * data->mv_size;     /* leave space for 2 more */
5999                                 } else {
6000                                         xdata.mv_size += 2 * (sizeof(indx_t) + NODESIZE) +
6001                                                 (dkey.mv_size & 1) + (data->mv_size & 1);
6002                                 }
6003                                 fp->mp_upper = xdata.mv_size;
6004                                 olddata.mv_size = fp->mp_upper; /* pretend olddata is fp */
6005                         } else if (leaf->mn_flags & F_SUBDATA) {
6006                                 /* Data is on sub-DB, just store it */
6007                                 flags |= F_DUPDATA|F_SUBDATA;
6008                                 goto put_sub;
6009                         } else {
6010                                 /* Data is on sub-page */
6011                                 fp = olddata.mv_data;
6012                                 switch (flags) {
6013                                 default:
6014                                         if (!(mc->mc_db->md_flags & MDB_DUPFIXED)) {
6015                                                 offset = EVEN(NODESIZE + sizeof(indx_t) +
6016                                                         data->mv_size);
6017                                                 break;
6018                                         }
6019                                         offset = fp->mp_pad;
6020                                         if (SIZELEFT(fp) < offset) {
6021                                                 offset *= 4; /* space for 4 more */
6022                                                 break;
6023                                         }
6024                                         /* FALLTHRU: Big enough MDB_DUPFIXED sub-page */
6025                                 case MDB_CURRENT:
6026                                         fp->mp_flags |= P_DIRTY;
6027                                         COPY_PGNO(fp->mp_pgno, mp->mp_pgno);
6028                                         mc->mc_xcursor->mx_cursor.mc_pg[0] = fp;
6029                                         flags |= F_DUPDATA;
6030                                         goto put_sub;
6031                                 }
6032                                 xdata.mv_size = olddata.mv_size + offset;
6033                         }
6034
6035                         fp_flags = fp->mp_flags;
6036                         if (NODESIZE + NODEKSZ(leaf) + xdata.mv_size > env->me_nodemax) {
6037                                         /* Too big for a sub-page, convert to sub-DB */
6038                                         fp_flags &= ~P_SUBP;
6039 prep_subDB:
6040                                         if (mc->mc_db->md_flags & MDB_DUPFIXED) {
6041                                                 fp_flags |= P_LEAF2;
6042                                                 dummy.md_pad = fp->mp_pad;
6043                                                 dummy.md_flags = MDB_DUPFIXED;
6044                                                 if (mc->mc_db->md_flags & MDB_INTEGERDUP)
6045                                                         dummy.md_flags |= MDB_INTEGERKEY;
6046                                         } else {
6047                                                 dummy.md_pad = 0;
6048                                                 dummy.md_flags = 0;
6049                                         }
6050                                         dummy.md_depth = 1;
6051                                         dummy.md_branch_pages = 0;
6052                                         dummy.md_leaf_pages = 1;
6053                                         dummy.md_overflow_pages = 0;
6054                                         dummy.md_entries = NUMKEYS(fp);
6055                                         xdata.mv_size = sizeof(MDB_db);
6056                                         xdata.mv_data = &dummy;
6057                                         if ((rc = mdb_page_alloc(mc, 1, &mp)))
6058                                                 return rc;
6059                                         offset = env->me_psize - olddata.mv_size;
6060                                         flags |= F_DUPDATA|F_SUBDATA;
6061                                         dummy.md_root = mp->mp_pgno;
6062                         }
6063                         if (mp != fp) {
6064                                 mp->mp_flags = fp_flags | P_DIRTY;
6065                                 mp->mp_pad   = fp->mp_pad;
6066                                 mp->mp_lower = fp->mp_lower;
6067                                 mp->mp_upper = fp->mp_upper + offset;
6068                                 if (fp_flags & P_LEAF2) {
6069                                         memcpy(METADATA(mp), METADATA(fp), NUMKEYS(fp) * fp->mp_pad);
6070                                 } else {
6071                                         memcpy((char *)mp + mp->mp_upper, (char *)fp + fp->mp_upper,
6072                                                 olddata.mv_size - fp->mp_upper);
6073                                         for (i=0; i<NUMKEYS(fp); i++)
6074                                                 mp->mp_ptrs[i] = fp->mp_ptrs[i] + offset;
6075                                 }
6076                         }
6077
6078                         rdata = &xdata;
6079                         flags |= F_DUPDATA;
6080                         do_sub = 1;
6081                         if (!insert_key)
6082                                 mdb_node_del(mc, 0);
6083                         goto new_sub;
6084                 }
6085 current:
6086                 /* overflow page overwrites need special handling */
6087                 if (F_ISSET(leaf->mn_flags, F_BIGDATA)) {
6088                         MDB_page *omp;
6089                         pgno_t pg;
6090                         int level, ovpages, dpages = OVPAGES(data->mv_size, env->me_psize);
6091
6092                         memcpy(&pg, olddata.mv_data, sizeof(pg));
6093                         if ((rc2 = mdb_page_get(mc->mc_txn, pg, &omp, &level)) != 0)
6094                                 return rc2;
6095                         ovpages = omp->mp_pages;
6096
6097                         /* Is the ov page large enough? */
6098                         if (ovpages >= dpages) {
6099                           if (!(omp->mp_flags & P_DIRTY) &&
6100                                   (level || (env->me_flags & MDB_WRITEMAP)))
6101                           {
6102                                 rc = mdb_page_unspill(mc->mc_txn, omp, &omp);
6103                                 if (rc)
6104                                         return rc;
6105                                 level = 0;              /* dirty in this txn or clean */
6106                           }
6107                           /* Is it dirty? */
6108                           if (omp->mp_flags & P_DIRTY) {
6109                                 /* yes, overwrite it. Note in this case we don't
6110                                  * bother to try shrinking the page if the new data
6111                                  * is smaller than the overflow threshold.
6112                                  */
6113                                 if (level > 1) {
6114                                         /* It is writable only in a parent txn */
6115                                         size_t sz = (size_t) env->me_psize * ovpages, off;
6116                                         MDB_page *np = mdb_page_malloc(mc->mc_txn, ovpages);
6117                                         MDB_ID2 id2;
6118                                         if (!np)
6119                                                 return ENOMEM;
6120                                         id2.mid = pg;
6121                                         id2.mptr = np;
6122                                         rc2 = mdb_mid2l_insert(mc->mc_txn->mt_u.dirty_list, &id2);
6123                                         mdb_cassert(mc, rc2 == 0);
6124                                         if (!(flags & MDB_RESERVE)) {
6125                                                 /* Copy end of page, adjusting alignment so
6126                                                  * compiler may copy words instead of bytes.
6127                                                  */
6128                                                 off = (PAGEHDRSZ + data->mv_size) & -sizeof(size_t);
6129                                                 memcpy((size_t *)((char *)np + off),
6130                                                         (size_t *)((char *)omp + off), sz - off);
6131                                                 sz = PAGEHDRSZ;
6132                                         }
6133                                         memcpy(np, omp, sz); /* Copy beginning of page */
6134                                         omp = np;
6135                                 }
6136                                 SETDSZ(leaf, data->mv_size);
6137                                 if (F_ISSET(flags, MDB_RESERVE))
6138                                         data->mv_data = METADATA(omp);
6139                                 else
6140                                         memcpy(METADATA(omp), data->mv_data, data->mv_size);
6141                                 return MDB_SUCCESS;
6142                           }
6143                         }
6144                         if ((rc2 = mdb_ovpage_free(mc, omp)) != MDB_SUCCESS)
6145                                 return rc2;
6146                 } else if (data->mv_size == olddata.mv_size) {
6147                         /* same size, just replace it. Note that we could
6148                          * also reuse this node if the new data is smaller,
6149                          * but instead we opt to shrink the node in that case.
6150                          */
6151                         if (F_ISSET(flags, MDB_RESERVE))
6152                                 data->mv_data = olddata.mv_data;
6153                         else if (!(mc->mc_flags & C_SUB))
6154                                 memcpy(olddata.mv_data, data->mv_data, data->mv_size);
6155                         else
6156                                 memcpy(NODEKEY(leaf), key->mv_data, key->mv_size);
6157                         return MDB_SUCCESS;
6158                 }
6159                 mdb_node_del(mc, 0);
6160         }
6161
6162         rdata = data;
6163
6164 new_sub:
6165         nflags = flags & NODE_ADD_FLAGS;
6166         nsize = IS_LEAF2(mc->mc_pg[mc->mc_top]) ? key->mv_size : mdb_leaf_size(env, key, rdata);
6167         if (SIZELEFT(mc->mc_pg[mc->mc_top]) < nsize) {
6168                 if (( flags & (F_DUPDATA|F_SUBDATA)) == F_DUPDATA )
6169                         nflags &= ~MDB_APPEND; /* sub-page may need room to grow */
6170                 if (!insert_key)
6171                         nflags |= MDB_SPLIT_REPLACE;
6172                 rc = mdb_page_split(mc, key, rdata, P_INVALID, nflags);
6173         } else {
6174                 /* There is room already in this leaf page. */
6175                 rc = mdb_node_add(mc, mc->mc_ki[mc->mc_top], key, rdata, 0, nflags);
6176                 if (rc == 0 && insert_key) {
6177                         /* Adjust other cursors pointing to mp */
6178                         MDB_cursor *m2, *m3;
6179                         MDB_dbi dbi = mc->mc_dbi;
6180                         unsigned i = mc->mc_top;
6181                         MDB_page *mp = mc->mc_pg[i];
6182
6183                         for (m2 = mc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
6184                                 if (mc->mc_flags & C_SUB)
6185                                         m3 = &m2->mc_xcursor->mx_cursor;
6186                                 else
6187                                         m3 = m2;
6188                                 if (m3 == mc || m3->mc_snum < mc->mc_snum) continue;
6189                                 if (m3->mc_pg[i] == mp && m3->mc_ki[i] >= mc->mc_ki[i]) {
6190                                         m3->mc_ki[i]++;
6191                                 }
6192                         }
6193                 }
6194         }
6195
6196         if (rc == MDB_SUCCESS) {
6197                 /* Now store the actual data in the child DB. Note that we're
6198                  * storing the user data in the keys field, so there are strict
6199                  * size limits on dupdata. The actual data fields of the child
6200                  * DB are all zero size.
6201                  */
6202                 if (do_sub) {
6203                         int xflags;
6204                         size_t ecount;
6205 put_sub:
6206                         xdata.mv_size = 0;
6207                         xdata.mv_data = "";
6208                         leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
6209                         if (flags & MDB_CURRENT) {
6210                                 xflags = MDB_CURRENT|MDB_NOSPILL;
6211                         } else {
6212                                 mdb_xcursor_init1(mc, leaf);
6213                                 xflags = (flags & MDB_NODUPDATA) ?
6214                                         MDB_NOOVERWRITE|MDB_NOSPILL : MDB_NOSPILL;
6215                         }
6216                         /* converted, write the original data first */
6217                         if (dkey.mv_size) {
6218                                 rc = mdb_cursor_put(&mc->mc_xcursor->mx_cursor, &dkey, &xdata, xflags);
6219                                 if (rc)
6220                                         goto bad_sub;
6221                                 {
6222                                         /* Adjust other cursors pointing to mp */
6223                                         MDB_cursor *m2;
6224                                         unsigned i = mc->mc_top;
6225                                         MDB_page *mp = mc->mc_pg[i];
6226
6227                                         for (m2 = mc->mc_txn->mt_cursors[mc->mc_dbi]; m2; m2=m2->mc_next) {
6228                                                 if (m2 == mc || m2->mc_snum < mc->mc_snum) continue;
6229                                                 if (!(m2->mc_flags & C_INITIALIZED)) continue;
6230                                                 if (m2->mc_pg[i] == mp && m2->mc_ki[i] == mc->mc_ki[i]) {
6231                                                         mdb_xcursor_init1(m2, leaf);
6232                                                 }
6233                                         }
6234                                 }
6235                                 /* we've done our job */
6236                                 dkey.mv_size = 0;
6237                         }
6238                         ecount = mc->mc_xcursor->mx_db.md_entries;
6239                         if (flags & MDB_APPENDDUP)
6240                                 xflags |= MDB_APPEND;
6241                         rc = mdb_cursor_put(&mc->mc_xcursor->mx_cursor, data, &xdata, xflags);
6242                         if (flags & F_SUBDATA) {
6243                                 void *db = NODEDATA(leaf);
6244                                 memcpy(db, &mc->mc_xcursor->mx_db, sizeof(MDB_db));
6245                         }
6246                         insert_data = mc->mc_xcursor->mx_db.md_entries - ecount;
6247                 }
6248                 /* Increment count unless we just replaced an existing item. */
6249                 if (insert_data)
6250                         mc->mc_db->md_entries++;
6251                 if (insert_key) {
6252                         /* Invalidate txn if we created an empty sub-DB */
6253                         if (rc)
6254                                 goto bad_sub;
6255                         /* If we succeeded and the key didn't exist before,
6256                          * make sure the cursor is marked valid.
6257                          */
6258                         mc->mc_flags |= C_INITIALIZED;
6259                 }
6260 next_sub:
6261                 if (flags & MDB_MULTIPLE) {
6262                         if (!rc) {
6263                                 mcount++;
6264                                 /* let caller know how many succeeded, if any */
6265                                 data[1].mv_size = mcount;
6266                                 if (mcount < dcount) {
6267                                         data[0].mv_data = (char *)data[0].mv_data + data[0].mv_size;
6268                                         insert_key = insert_data = 0;
6269                                         goto more;
6270                                 }
6271                         }
6272                 }
6273                 return rc;
6274 bad_sub:
6275                 if (rc == MDB_KEYEXIST) /* should not happen, we deleted that item */
6276                         rc = MDB_CORRUPTED;
6277         }
6278         mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
6279         return rc;
6280 }
6281
6282 int
6283 mdb_cursor_del(MDB_cursor *mc, unsigned int flags)
6284 {
6285         MDB_node        *leaf;
6286         MDB_page        *mp;
6287         int rc;
6288
6289         if (mc->mc_txn->mt_flags & (MDB_TXN_RDONLY|MDB_TXN_ERROR))
6290                 return (mc->mc_txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
6291
6292         if (!(mc->mc_flags & C_INITIALIZED))
6293                 return EINVAL;
6294
6295         if (mc->mc_ki[mc->mc_top] >= NUMKEYS(mc->mc_pg[mc->mc_top]))
6296                 return MDB_NOTFOUND;
6297
6298         if (!(flags & MDB_NOSPILL) && (rc = mdb_page_spill(mc, NULL, NULL)))
6299                 return rc;
6300
6301         rc = mdb_cursor_touch(mc);
6302         if (rc)
6303                 return rc;
6304
6305         mp = mc->mc_pg[mc->mc_top];
6306         if (IS_LEAF2(mp))
6307                 goto del_key;
6308         leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
6309
6310         if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
6311                 if (flags & MDB_NODUPDATA) {
6312                         /* mdb_cursor_del0() will subtract the final entry */
6313                         mc->mc_db->md_entries -= mc->mc_xcursor->mx_db.md_entries - 1;
6314                 } else {
6315                         if (!F_ISSET(leaf->mn_flags, F_SUBDATA)) {
6316                                 mc->mc_xcursor->mx_cursor.mc_pg[0] = NODEDATA(leaf);
6317                         }
6318                         rc = mdb_cursor_del(&mc->mc_xcursor->mx_cursor, MDB_NOSPILL);
6319                         if (rc)
6320                                 return rc;
6321                         /* If sub-DB still has entries, we're done */
6322                         if (mc->mc_xcursor->mx_db.md_entries) {
6323                                 if (leaf->mn_flags & F_SUBDATA) {
6324                                         /* update subDB info */
6325                                         void *db = NODEDATA(leaf);
6326                                         memcpy(db, &mc->mc_xcursor->mx_db, sizeof(MDB_db));
6327                                 } else {
6328                                         MDB_cursor *m2;
6329                                         /* shrink fake page */
6330                                         mdb_node_shrink(mp, mc->mc_ki[mc->mc_top]);
6331                                         leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
6332                                         mc->mc_xcursor->mx_cursor.mc_pg[0] = NODEDATA(leaf);
6333                                         /* fix other sub-DB cursors pointed at this fake page */
6334                                         for (m2 = mc->mc_txn->mt_cursors[mc->mc_dbi]; m2; m2=m2->mc_next) {
6335                                                 if (m2 == mc || m2->mc_snum < mc->mc_snum) continue;
6336                                                 if (m2->mc_pg[mc->mc_top] == mp &&
6337                                                         m2->mc_ki[mc->mc_top] == mc->mc_ki[mc->mc_top])
6338                                                         m2->mc_xcursor->mx_cursor.mc_pg[0] = NODEDATA(leaf);
6339                                         }
6340                                 }
6341                                 mc->mc_db->md_entries--;
6342                                 mc->mc_flags |= C_DEL;
6343                                 return rc;
6344                         }
6345                         /* otherwise fall thru and delete the sub-DB */
6346                 }
6347
6348                 if (leaf->mn_flags & F_SUBDATA) {
6349                         /* add all the child DB's pages to the free list */
6350                         rc = mdb_drop0(&mc->mc_xcursor->mx_cursor, 0);
6351                         if (rc)
6352                                 goto fail;
6353                 }
6354         }
6355
6356         /* add overflow pages to free list */
6357         if (F_ISSET(leaf->mn_flags, F_BIGDATA)) {
6358                 MDB_page *omp;
6359                 pgno_t pg;
6360
6361                 memcpy(&pg, NODEDATA(leaf), sizeof(pg));
6362                 if ((rc = mdb_page_get(mc->mc_txn, pg, &omp, NULL)) ||
6363                         (rc = mdb_ovpage_free(mc, omp)))
6364                         goto fail;
6365         }
6366
6367 del_key:
6368         return mdb_cursor_del0(mc);
6369
6370 fail:
6371         mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
6372         return rc;
6373 }
6374
6375 /** Allocate and initialize new pages for a database.
6376  * @param[in] mc a cursor on the database being added to.
6377  * @param[in] flags flags defining what type of page is being allocated.
6378  * @param[in] num the number of pages to allocate. This is usually 1,
6379  * unless allocating overflow pages for a large record.
6380  * @param[out] mp Address of a page, or NULL on failure.
6381  * @return 0 on success, non-zero on failure.
6382  */
6383 static int
6384 mdb_page_new(MDB_cursor *mc, uint32_t flags, int num, MDB_page **mp)
6385 {
6386         MDB_page        *np;
6387         int rc;
6388
6389         if ((rc = mdb_page_alloc(mc, num, &np)))
6390                 return rc;
6391         DPRINTF(("allocated new mpage %"Z"u, page size %u",
6392             np->mp_pgno, mc->mc_txn->mt_env->me_psize));
6393         np->mp_flags = flags | P_DIRTY;
6394         np->mp_lower = PAGEHDRSZ;
6395         np->mp_upper = mc->mc_txn->mt_env->me_psize;
6396
6397         if (IS_BRANCH(np))
6398                 mc->mc_db->md_branch_pages++;
6399         else if (IS_LEAF(np))
6400                 mc->mc_db->md_leaf_pages++;
6401         else if (IS_OVERFLOW(np)) {
6402                 mc->mc_db->md_overflow_pages += num;
6403                 np->mp_pages = num;
6404         }
6405         *mp = np;
6406
6407         return 0;
6408 }
6409
6410 /** Calculate the size of a leaf node.
6411  * The size depends on the environment's page size; if a data item
6412  * is too large it will be put onto an overflow page and the node
6413  * size will only include the key and not the data. Sizes are always
6414  * rounded up to an even number of bytes, to guarantee 2-byte alignment
6415  * of the #MDB_node headers.
6416  * @param[in] env The environment handle.
6417  * @param[in] key The key for the node.
6418  * @param[in] data The data for the node.
6419  * @return The number of bytes needed to store the node.
6420  */
6421 static size_t
6422 mdb_leaf_size(MDB_env *env, MDB_val *key, MDB_val *data)
6423 {
6424         size_t           sz;
6425
6426         sz = LEAFSIZE(key, data);
6427         if (sz > env->me_nodemax) {
6428                 /* put on overflow page */
6429                 sz -= data->mv_size - sizeof(pgno_t);
6430         }
6431
6432         return EVEN(sz + sizeof(indx_t));
6433 }
6434
6435 /** Calculate the size of a branch node.
6436  * The size should depend on the environment's page size but since
6437  * we currently don't support spilling large keys onto overflow
6438  * pages, it's simply the size of the #MDB_node header plus the
6439  * size of the key. Sizes are always rounded up to an even number
6440  * of bytes, to guarantee 2-byte alignment of the #MDB_node headers.
6441  * @param[in] env The environment handle.
6442  * @param[in] key The key for the node.
6443  * @return The number of bytes needed to store the node.
6444  */
6445 static size_t
6446 mdb_branch_size(MDB_env *env, MDB_val *key)
6447 {
6448         size_t           sz;
6449
6450         sz = INDXSIZE(key);
6451         if (sz > env->me_nodemax) {
6452                 /* put on overflow page */
6453                 /* not implemented */
6454                 /* sz -= key->size - sizeof(pgno_t); */
6455         }
6456
6457         return sz + sizeof(indx_t);
6458 }
6459
6460 /** Add a node to the page pointed to by the cursor.
6461  * @param[in] mc The cursor for this operation.
6462  * @param[in] indx The index on the page where the new node should be added.
6463  * @param[in] key The key for the new node.
6464  * @param[in] data The data for the new node, if any.
6465  * @param[in] pgno The page number, if adding a branch node.
6466  * @param[in] flags Flags for the node.
6467  * @return 0 on success, non-zero on failure. Possible errors are:
6468  * <ul>
6469  *      <li>ENOMEM - failed to allocate overflow pages for the node.
6470  *      <li>MDB_PAGE_FULL - there is insufficient room in the page. This error
6471  *      should never happen since all callers already calculate the
6472  *      page's free space before calling this function.
6473  * </ul>
6474  */
6475 static int
6476 mdb_node_add(MDB_cursor *mc, indx_t indx,
6477     MDB_val *key, MDB_val *data, pgno_t pgno, unsigned int flags)
6478 {
6479         unsigned int     i;
6480         size_t           node_size = NODESIZE;
6481         ssize_t          room;
6482         indx_t           ofs;
6483         MDB_node        *node;
6484         MDB_page        *mp = mc->mc_pg[mc->mc_top];
6485         MDB_page        *ofp = NULL;            /* overflow page */
6486         DKBUF;
6487
6488         mdb_cassert(mc, mp->mp_upper >= mp->mp_lower);
6489
6490         DPRINTF(("add to %s %spage %"Z"u index %i, data size %"Z"u key size %"Z"u [%s]",
6491             IS_LEAF(mp) ? "leaf" : "branch",
6492                 IS_SUBP(mp) ? "sub-" : "",
6493                 mdb_dbg_pgno(mp), indx, data ? data->mv_size : 0,
6494                 key ? key->mv_size : 0, key ? DKEY(key) : "null"));
6495
6496         if (IS_LEAF2(mp)) {
6497                 /* Move higher keys up one slot. */
6498                 int ksize = mc->mc_db->md_pad, dif;
6499                 char *ptr = LEAF2KEY(mp, indx, ksize);
6500                 dif = NUMKEYS(mp) - indx;
6501                 if (dif > 0)
6502                         memmove(ptr+ksize, ptr, dif*ksize);
6503                 /* insert new key */
6504                 memcpy(ptr, key->mv_data, ksize);
6505
6506                 /* Just using these for counting */
6507                 mp->mp_lower += sizeof(indx_t);
6508                 mp->mp_upper -= ksize - sizeof(indx_t);
6509                 return MDB_SUCCESS;
6510         }
6511
6512         room = (ssize_t)SIZELEFT(mp) - (ssize_t)sizeof(indx_t);
6513         if (key != NULL)
6514                 node_size += key->mv_size;
6515         if (IS_LEAF(mp)) {
6516                 mdb_cassert(mc, data);
6517                 if (F_ISSET(flags, F_BIGDATA)) {
6518                         /* Data already on overflow page. */
6519                         node_size += sizeof(pgno_t);
6520                 } else if (node_size + data->mv_size > mc->mc_txn->mt_env->me_nodemax) {
6521                         int ovpages = OVPAGES(data->mv_size, mc->mc_txn->mt_env->me_psize);
6522                         int rc;
6523                         /* Put data on overflow page. */
6524                         DPRINTF(("data size is %"Z"u, node would be %"Z"u, put data on overflow page",
6525                             data->mv_size, node_size+data->mv_size));
6526                         node_size = EVEN(node_size + sizeof(pgno_t));
6527                         if ((ssize_t)node_size > room)
6528                                 goto full;
6529                         if ((rc = mdb_page_new(mc, P_OVERFLOW, ovpages, &ofp)))
6530                                 return rc;
6531                         DPRINTF(("allocated overflow page %"Z"u", ofp->mp_pgno));
6532                         flags |= F_BIGDATA;
6533                         goto update;
6534                 } else {
6535                         node_size += data->mv_size;
6536                 }
6537         }
6538         node_size = EVEN(node_size);
6539         if ((ssize_t)node_size > room)
6540                 goto full;
6541
6542 update:
6543         /* Move higher pointers up one slot. */
6544         for (i = NUMKEYS(mp); i > indx; i--)
6545                 mp->mp_ptrs[i] = mp->mp_ptrs[i - 1];
6546
6547         /* Adjust free space offsets. */
6548         ofs = mp->mp_upper - node_size;
6549         mdb_cassert(mc, ofs >= mp->mp_lower + sizeof(indx_t));
6550         mp->mp_ptrs[indx] = ofs;
6551         mp->mp_upper = ofs;
6552         mp->mp_lower += sizeof(indx_t);
6553
6554         /* Write the node data. */
6555         node = NODEPTR(mp, indx);
6556         node->mn_ksize = (key == NULL) ? 0 : key->mv_size;
6557         node->mn_flags = flags;
6558         if (IS_LEAF(mp))
6559                 SETDSZ(node,data->mv_size);
6560         else
6561                 SETPGNO(node,pgno);
6562
6563         if (key)
6564                 memcpy(NODEKEY(node), key->mv_data, key->mv_size);
6565
6566         if (IS_LEAF(mp)) {
6567                 mdb_cassert(mc, key);
6568                 if (ofp == NULL) {
6569                         if (F_ISSET(flags, F_BIGDATA))
6570                                 memcpy(node->mn_data + key->mv_size, data->mv_data,
6571                                     sizeof(pgno_t));
6572                         else if (F_ISSET(flags, MDB_RESERVE))
6573                                 data->mv_data = node->mn_data + key->mv_size;
6574                         else
6575                                 memcpy(node->mn_data + key->mv_size, data->mv_data,
6576                                     data->mv_size);
6577                 } else {
6578                         memcpy(node->mn_data + key->mv_size, &ofp->mp_pgno,
6579                             sizeof(pgno_t));
6580                         if (F_ISSET(flags, MDB_RESERVE))
6581                                 data->mv_data = METADATA(ofp);
6582                         else
6583                                 memcpy(METADATA(ofp), data->mv_data, data->mv_size);
6584                 }
6585         }
6586
6587         return MDB_SUCCESS;
6588
6589 full:
6590         DPRINTF(("not enough room in page %"Z"u, got %u ptrs",
6591                 mdb_dbg_pgno(mp), NUMKEYS(mp)));
6592         DPRINTF(("upper-lower = %u - %u = %"Z"d", mp->mp_upper,mp->mp_lower,room));
6593         DPRINTF(("node size = %"Z"u", node_size));
6594         mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
6595         return MDB_PAGE_FULL;
6596 }
6597
6598 /** Delete the specified node from a page.
6599  * @param[in] mc Cursor pointing to the node to delete.
6600  * @param[in] ksize The size of a node. Only used if the page is
6601  * part of a #MDB_DUPFIXED database.
6602  */
6603 static void
6604 mdb_node_del(MDB_cursor *mc, int ksize)
6605 {
6606         MDB_page *mp = mc->mc_pg[mc->mc_top];
6607         indx_t  indx = mc->mc_ki[mc->mc_top];
6608         unsigned int     sz;
6609         indx_t           i, j, numkeys, ptr;
6610         MDB_node        *node;
6611         char            *base;
6612
6613         DPRINTF(("delete node %u on %s page %"Z"u", indx,
6614             IS_LEAF(mp) ? "leaf" : "branch", mdb_dbg_pgno(mp)));
6615         numkeys = NUMKEYS(mp);
6616         mdb_cassert(mc, indx < numkeys);
6617
6618         if (IS_LEAF2(mp)) {
6619                 int x = numkeys - 1 - indx;
6620                 base = LEAF2KEY(mp, indx, ksize);
6621                 if (x)
6622                         memmove(base, base + ksize, x * ksize);
6623                 mp->mp_lower -= sizeof(indx_t);
6624                 mp->mp_upper += ksize - sizeof(indx_t);
6625                 return;
6626         }
6627
6628         node = NODEPTR(mp, indx);
6629         sz = NODESIZE + node->mn_ksize;
6630         if (IS_LEAF(mp)) {
6631                 if (F_ISSET(node->mn_flags, F_BIGDATA))
6632                         sz += sizeof(pgno_t);
6633                 else
6634                         sz += NODEDSZ(node);
6635         }
6636         sz = EVEN(sz);
6637
6638         ptr = mp->mp_ptrs[indx];
6639         for (i = j = 0; i < numkeys; i++) {
6640                 if (i != indx) {
6641                         mp->mp_ptrs[j] = mp->mp_ptrs[i];
6642                         if (mp->mp_ptrs[i] < ptr)
6643                                 mp->mp_ptrs[j] += sz;
6644                         j++;
6645                 }
6646         }
6647
6648         base = (char *)mp + mp->mp_upper;
6649         memmove(base + sz, base, ptr - mp->mp_upper);
6650
6651         mp->mp_lower -= sizeof(indx_t);
6652         mp->mp_upper += sz;
6653 }
6654
6655 /** Compact the main page after deleting a node on a subpage.
6656  * @param[in] mp The main page to operate on.
6657  * @param[in] indx The index of the subpage on the main page.
6658  */
6659 static void
6660 mdb_node_shrink(MDB_page *mp, indx_t indx)
6661 {
6662         MDB_node *node;
6663         MDB_page *sp, *xp;
6664         char *base;
6665         int nsize, delta;
6666         indx_t           i, numkeys, ptr;
6667
6668         node = NODEPTR(mp, indx);
6669         sp = (MDB_page *)NODEDATA(node);
6670         delta = SIZELEFT(sp);
6671         xp = (MDB_page *)((char *)sp + delta);
6672
6673         /* shift subpage upward */
6674         if (IS_LEAF2(sp)) {
6675                 nsize = NUMKEYS(sp) * sp->mp_pad;
6676                 if (nsize & 1)
6677                         return;         /* do not make the node uneven-sized */
6678                 memmove(METADATA(xp), METADATA(sp), nsize);
6679         } else {
6680                 int i;
6681                 numkeys = NUMKEYS(sp);
6682                 for (i=numkeys-1; i>=0; i--)
6683                         xp->mp_ptrs[i] = sp->mp_ptrs[i] - delta;
6684         }
6685         xp->mp_upper = sp->mp_lower;
6686         xp->mp_lower = sp->mp_lower;
6687         xp->mp_flags = sp->mp_flags;
6688         xp->mp_pad = sp->mp_pad;
6689         COPY_PGNO(xp->mp_pgno, mp->mp_pgno);
6690
6691         nsize = NODEDSZ(node) - delta;
6692         SETDSZ(node, nsize);
6693
6694         /* shift lower nodes upward */
6695         ptr = mp->mp_ptrs[indx];
6696         numkeys = NUMKEYS(mp);
6697         for (i = 0; i < numkeys; i++) {
6698                 if (mp->mp_ptrs[i] <= ptr)
6699                         mp->mp_ptrs[i] += delta;
6700         }
6701
6702         base = (char *)mp + mp->mp_upper;
6703         memmove(base + delta, base, ptr - mp->mp_upper + NODESIZE + NODEKSZ(node));
6704         mp->mp_upper += delta;
6705 }
6706
6707 /** Initial setup of a sorted-dups cursor.
6708  * Sorted duplicates are implemented as a sub-database for the given key.
6709  * The duplicate data items are actually keys of the sub-database.
6710  * Operations on the duplicate data items are performed using a sub-cursor
6711  * initialized when the sub-database is first accessed. This function does
6712  * the preliminary setup of the sub-cursor, filling in the fields that
6713  * depend only on the parent DB.
6714  * @param[in] mc The main cursor whose sorted-dups cursor is to be initialized.
6715  */
6716 static void
6717 mdb_xcursor_init0(MDB_cursor *mc)
6718 {
6719         MDB_xcursor *mx = mc->mc_xcursor;
6720
6721         mx->mx_cursor.mc_xcursor = NULL;
6722         mx->mx_cursor.mc_txn = mc->mc_txn;
6723         mx->mx_cursor.mc_db = &mx->mx_db;
6724         mx->mx_cursor.mc_dbx = &mx->mx_dbx;
6725         mx->mx_cursor.mc_dbi = mc->mc_dbi;
6726         mx->mx_cursor.mc_dbflag = &mx->mx_dbflag;
6727         mx->mx_cursor.mc_snum = 0;
6728         mx->mx_cursor.mc_top = 0;
6729         mx->mx_cursor.mc_flags = C_SUB;
6730         mx->mx_dbx.md_name.mv_size = 0;
6731         mx->mx_dbx.md_name.mv_data = NULL;
6732         mx->mx_dbx.md_cmp = mc->mc_dbx->md_dcmp;
6733         mx->mx_dbx.md_dcmp = NULL;
6734         mx->mx_dbx.md_rel = mc->mc_dbx->md_rel;
6735 }
6736
6737 /** Final setup of a sorted-dups cursor.
6738  *      Sets up the fields that depend on the data from the main cursor.
6739  * @param[in] mc The main cursor whose sorted-dups cursor is to be initialized.
6740  * @param[in] node The data containing the #MDB_db record for the
6741  * sorted-dup database.
6742  */
6743 static void
6744 mdb_xcursor_init1(MDB_cursor *mc, MDB_node *node)
6745 {
6746         MDB_xcursor *mx = mc->mc_xcursor;
6747
6748         if (node->mn_flags & F_SUBDATA) {
6749                 memcpy(&mx->mx_db, NODEDATA(node), sizeof(MDB_db));
6750                 mx->mx_cursor.mc_pg[0] = 0;
6751                 mx->mx_cursor.mc_snum = 0;
6752                 mx->mx_cursor.mc_top = 0;
6753                 mx->mx_cursor.mc_flags = C_SUB;
6754         } else {
6755                 MDB_page *fp = NODEDATA(node);
6756                 mx->mx_db.md_pad = mc->mc_pg[mc->mc_top]->mp_pad;
6757                 mx->mx_db.md_flags = 0;
6758                 mx->mx_db.md_depth = 1;
6759                 mx->mx_db.md_branch_pages = 0;
6760                 mx->mx_db.md_leaf_pages = 1;
6761                 mx->mx_db.md_overflow_pages = 0;
6762                 mx->mx_db.md_entries = NUMKEYS(fp);
6763                 COPY_PGNO(mx->mx_db.md_root, fp->mp_pgno);
6764                 mx->mx_cursor.mc_snum = 1;
6765                 mx->mx_cursor.mc_top = 0;
6766                 mx->mx_cursor.mc_flags = C_INITIALIZED|C_SUB;
6767                 mx->mx_cursor.mc_pg[0] = fp;
6768                 mx->mx_cursor.mc_ki[0] = 0;
6769                 if (mc->mc_db->md_flags & MDB_DUPFIXED) {
6770                         mx->mx_db.md_flags = MDB_DUPFIXED;
6771                         mx->mx_db.md_pad = fp->mp_pad;
6772                         if (mc->mc_db->md_flags & MDB_INTEGERDUP)
6773                                 mx->mx_db.md_flags |= MDB_INTEGERKEY;
6774                 }
6775         }
6776         DPRINTF(("Sub-db -%u root page %"Z"u", mx->mx_cursor.mc_dbi,
6777                 mx->mx_db.md_root));
6778         mx->mx_dbflag = DB_VALID|DB_DIRTY; /* DB_DIRTY guides mdb_cursor_touch */
6779 #if UINT_MAX < SIZE_MAX
6780         if (mx->mx_dbx.md_cmp == mdb_cmp_int && mx->mx_db.md_pad == sizeof(size_t))
6781                 mx->mx_dbx.md_cmp = mdb_cmp_clong;
6782 #endif
6783 }
6784
6785 /** Initialize a cursor for a given transaction and database. */
6786 static void
6787 mdb_cursor_init(MDB_cursor *mc, MDB_txn *txn, MDB_dbi dbi, MDB_xcursor *mx)
6788 {
6789         mc->mc_next = NULL;
6790         mc->mc_backup = NULL;
6791         mc->mc_dbi = dbi;
6792         mc->mc_txn = txn;
6793         mc->mc_db = &txn->mt_dbs[dbi];
6794         mc->mc_dbx = &txn->mt_dbxs[dbi];
6795         mc->mc_dbflag = &txn->mt_dbflags[dbi];
6796         mc->mc_snum = 0;
6797         mc->mc_top = 0;
6798         mc->mc_pg[0] = 0;
6799         mc->mc_flags = 0;
6800         if (txn->mt_dbs[dbi].md_flags & MDB_DUPSORT) {
6801                 mdb_tassert(txn, mx != NULL);
6802                 mc->mc_xcursor = mx;
6803                 mdb_xcursor_init0(mc);
6804         } else {
6805                 mc->mc_xcursor = NULL;
6806         }
6807         if (*mc->mc_dbflag & DB_STALE) {
6808                 mdb_page_search(mc, NULL, MDB_PS_ROOTONLY);
6809         }
6810 }
6811
6812 int
6813 mdb_cursor_open(MDB_txn *txn, MDB_dbi dbi, MDB_cursor **ret)
6814 {
6815         MDB_cursor      *mc;
6816         size_t size = sizeof(MDB_cursor);
6817
6818         if (!ret || !TXN_DBI_EXIST(txn, dbi))
6819                 return EINVAL;
6820
6821         if (txn->mt_flags & MDB_TXN_ERROR)
6822                 return MDB_BAD_TXN;
6823
6824         /* Allow read access to the freelist */
6825         if (!dbi && !F_ISSET(txn->mt_flags, MDB_TXN_RDONLY))
6826                 return EINVAL;
6827
6828         if (txn->mt_dbs[dbi].md_flags & MDB_DUPSORT)
6829                 size += sizeof(MDB_xcursor);
6830
6831         if ((mc = malloc(size)) != NULL) {
6832                 mdb_cursor_init(mc, txn, dbi, (MDB_xcursor *)(mc + 1));
6833                 if (txn->mt_cursors) {
6834                         mc->mc_next = txn->mt_cursors[dbi];
6835                         txn->mt_cursors[dbi] = mc;
6836                         mc->mc_flags |= C_UNTRACK;
6837                 }
6838         } else {
6839                 return ENOMEM;
6840         }
6841
6842         *ret = mc;
6843
6844         return MDB_SUCCESS;
6845 }
6846
6847 int
6848 mdb_cursor_renew(MDB_txn *txn, MDB_cursor *mc)
6849 {
6850         if (!mc || !TXN_DBI_EXIST(txn, mc->mc_dbi))
6851                 return EINVAL;
6852
6853         if ((mc->mc_flags & C_UNTRACK) || txn->mt_cursors)
6854                 return EINVAL;
6855
6856         if (txn->mt_flags & MDB_TXN_ERROR)
6857                 return MDB_BAD_TXN;
6858
6859         mdb_cursor_init(mc, txn, mc->mc_dbi, mc->mc_xcursor);
6860         return MDB_SUCCESS;
6861 }
6862
6863 /* Return the count of duplicate data items for the current key */
6864 int
6865 mdb_cursor_count(MDB_cursor *mc, size_t *countp)
6866 {
6867         MDB_node        *leaf;
6868
6869         if (mc == NULL || countp == NULL)
6870                 return EINVAL;
6871
6872         if (mc->mc_xcursor == NULL)
6873                 return MDB_INCOMPATIBLE;
6874
6875         if (mc->mc_txn->mt_flags & MDB_TXN_ERROR)
6876                 return MDB_BAD_TXN;
6877
6878         leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
6879         if (!F_ISSET(leaf->mn_flags, F_DUPDATA)) {
6880                 *countp = 1;
6881         } else {
6882                 if (!(mc->mc_xcursor->mx_cursor.mc_flags & C_INITIALIZED))
6883                         return EINVAL;
6884
6885                 *countp = mc->mc_xcursor->mx_db.md_entries;
6886         }
6887         return MDB_SUCCESS;
6888 }
6889
6890 void
6891 mdb_cursor_close(MDB_cursor *mc)
6892 {
6893         if (mc && !mc->mc_backup) {
6894                 /* remove from txn, if tracked */
6895                 if ((mc->mc_flags & C_UNTRACK) && mc->mc_txn->mt_cursors) {
6896                         MDB_cursor **prev = &mc->mc_txn->mt_cursors[mc->mc_dbi];
6897                         while (*prev && *prev != mc) prev = &(*prev)->mc_next;
6898                         if (*prev == mc)
6899                                 *prev = mc->mc_next;
6900                 }
6901                 free(mc);
6902         }
6903 }
6904
6905 MDB_txn *
6906 mdb_cursor_txn(MDB_cursor *mc)
6907 {
6908         if (!mc) return NULL;
6909         return mc->mc_txn;
6910 }
6911
6912 MDB_dbi
6913 mdb_cursor_dbi(MDB_cursor *mc)
6914 {
6915         return mc->mc_dbi;
6916 }
6917
6918 /** Replace the key for a branch node with a new key.
6919  * @param[in] mc Cursor pointing to the node to operate on.
6920  * @param[in] key The new key to use.
6921  * @return 0 on success, non-zero on failure.
6922  */
6923 static int
6924 mdb_update_key(MDB_cursor *mc, MDB_val *key)
6925 {
6926         MDB_page                *mp;
6927         MDB_node                *node;
6928         char                    *base;
6929         size_t                   len;
6930         int                              delta, ksize, oksize;
6931         indx_t                   ptr, i, numkeys, indx;
6932         DKBUF;
6933
6934         indx = mc->mc_ki[mc->mc_top];
6935         mp = mc->mc_pg[mc->mc_top];
6936         node = NODEPTR(mp, indx);
6937         ptr = mp->mp_ptrs[indx];
6938 #if MDB_DEBUG
6939         {
6940                 MDB_val k2;
6941                 char kbuf2[DKBUF_MAXKEYSIZE*2+1];
6942                 k2.mv_data = NODEKEY(node);
6943                 k2.mv_size = node->mn_ksize;
6944                 DPRINTF(("update key %u (ofs %u) [%s] to [%s] on page %"Z"u",
6945                         indx, ptr,
6946                         mdb_dkey(&k2, kbuf2),
6947                         DKEY(key),
6948                         mp->mp_pgno));
6949         }
6950 #endif
6951
6952         /* Sizes must be 2-byte aligned. */
6953         ksize = EVEN(key->mv_size);
6954         oksize = EVEN(node->mn_ksize);
6955         delta = ksize - oksize;
6956
6957         /* Shift node contents if EVEN(key length) changed. */
6958         if (delta) {
6959                 if (delta > 0 && SIZELEFT(mp) < delta) {
6960                         pgno_t pgno;
6961                         /* not enough space left, do a delete and split */
6962                         DPRINTF(("Not enough room, delta = %d, splitting...", delta));
6963                         pgno = NODEPGNO(node);
6964                         mdb_node_del(mc, 0);
6965                         return mdb_page_split(mc, key, NULL, pgno, MDB_SPLIT_REPLACE);
6966                 }
6967
6968                 numkeys = NUMKEYS(mp);
6969                 for (i = 0; i < numkeys; i++) {
6970                         if (mp->mp_ptrs[i] <= ptr)
6971                                 mp->mp_ptrs[i] -= delta;
6972                 }
6973
6974                 base = (char *)mp + mp->mp_upper;
6975                 len = ptr - mp->mp_upper + NODESIZE;
6976                 memmove(base - delta, base, len);
6977                 mp->mp_upper -= delta;
6978
6979                 node = NODEPTR(mp, indx);
6980         }
6981
6982         /* But even if no shift was needed, update ksize */
6983         if (node->mn_ksize != key->mv_size)
6984                 node->mn_ksize = key->mv_size;
6985
6986         if (key->mv_size)
6987                 memcpy(NODEKEY(node), key->mv_data, key->mv_size);
6988
6989         return MDB_SUCCESS;
6990 }
6991
6992 static void
6993 mdb_cursor_copy(const MDB_cursor *csrc, MDB_cursor *cdst);
6994
6995 /** Move a node from csrc to cdst.
6996  */
6997 static int
6998 mdb_node_move(MDB_cursor *csrc, MDB_cursor *cdst)
6999 {
7000         MDB_node                *srcnode;
7001         MDB_val          key, data;
7002         pgno_t  srcpg;
7003         MDB_cursor mn;
7004         int                      rc;
7005         unsigned short flags;
7006
7007         DKBUF;
7008
7009         /* Mark src and dst as dirty. */
7010         if ((rc = mdb_page_touch(csrc)) ||
7011             (rc = mdb_page_touch(cdst)))
7012                 return rc;
7013
7014         if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7015                 key.mv_size = csrc->mc_db->md_pad;
7016                 key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], csrc->mc_ki[csrc->mc_top], key.mv_size);
7017                 data.mv_size = 0;
7018                 data.mv_data = NULL;
7019                 srcpg = 0;
7020                 flags = 0;
7021         } else {
7022                 srcnode = NODEPTR(csrc->mc_pg[csrc->mc_top], csrc->mc_ki[csrc->mc_top]);
7023                 mdb_cassert(csrc, !((size_t)srcnode & 1));
7024                 srcpg = NODEPGNO(srcnode);
7025                 flags = srcnode->mn_flags;
7026                 if (csrc->mc_ki[csrc->mc_top] == 0 && IS_BRANCH(csrc->mc_pg[csrc->mc_top])) {
7027                         unsigned int snum = csrc->mc_snum;
7028                         MDB_node *s2;
7029                         /* must find the lowest key below src */
7030                         rc = mdb_page_search_lowest(csrc);
7031                         if (rc)
7032                                 return rc;
7033                         if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7034                                 key.mv_size = csrc->mc_db->md_pad;
7035                                 key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], 0, key.mv_size);
7036                         } else {
7037                                 s2 = NODEPTR(csrc->mc_pg[csrc->mc_top], 0);
7038                                 key.mv_size = NODEKSZ(s2);
7039                                 key.mv_data = NODEKEY(s2);
7040                         }
7041                         csrc->mc_snum = snum--;
7042                         csrc->mc_top = snum;
7043                 } else {
7044                         key.mv_size = NODEKSZ(srcnode);
7045                         key.mv_data = NODEKEY(srcnode);
7046                 }
7047                 data.mv_size = NODEDSZ(srcnode);
7048                 data.mv_data = NODEDATA(srcnode);
7049         }
7050         if (IS_BRANCH(cdst->mc_pg[cdst->mc_top]) && cdst->mc_ki[cdst->mc_top] == 0) {
7051                 unsigned int snum = cdst->mc_snum;
7052                 MDB_node *s2;
7053                 MDB_val bkey;
7054                 /* must find the lowest key below dst */
7055                 rc = mdb_page_search_lowest(cdst);
7056                 if (rc)
7057                         return rc;
7058                 if (IS_LEAF2(cdst->mc_pg[cdst->mc_top])) {
7059                         bkey.mv_size = cdst->mc_db->md_pad;
7060                         bkey.mv_data = LEAF2KEY(cdst->mc_pg[cdst->mc_top], 0, bkey.mv_size);
7061                 } else {
7062                         s2 = NODEPTR(cdst->mc_pg[cdst->mc_top], 0);
7063                         bkey.mv_size = NODEKSZ(s2);
7064                         bkey.mv_data = NODEKEY(s2);
7065                 }
7066                 cdst->mc_snum = snum--;
7067                 cdst->mc_top = snum;
7068                 mdb_cursor_copy(cdst, &mn);
7069                 mn.mc_ki[snum] = 0;
7070                 rc = mdb_update_key(&mn, &bkey);
7071                 if (rc)
7072                         return rc;
7073         }
7074
7075         DPRINTF(("moving %s node %u [%s] on page %"Z"u to node %u on page %"Z"u",
7076             IS_LEAF(csrc->mc_pg[csrc->mc_top]) ? "leaf" : "branch",
7077             csrc->mc_ki[csrc->mc_top],
7078                 DKEY(&key),
7079             csrc->mc_pg[csrc->mc_top]->mp_pgno,
7080             cdst->mc_ki[cdst->mc_top], cdst->mc_pg[cdst->mc_top]->mp_pgno));
7081
7082         /* Add the node to the destination page.
7083          */
7084         rc = mdb_node_add(cdst, cdst->mc_ki[cdst->mc_top], &key, &data, srcpg, flags);
7085         if (rc != MDB_SUCCESS)
7086                 return rc;
7087
7088         /* Delete the node from the source page.
7089          */
7090         mdb_node_del(csrc, key.mv_size);
7091
7092         {
7093                 /* Adjust other cursors pointing to mp */
7094                 MDB_cursor *m2, *m3;
7095                 MDB_dbi dbi = csrc->mc_dbi;
7096                 MDB_page *mp = csrc->mc_pg[csrc->mc_top];
7097
7098                 for (m2 = csrc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7099                         if (csrc->mc_flags & C_SUB)
7100                                 m3 = &m2->mc_xcursor->mx_cursor;
7101                         else
7102                                 m3 = m2;
7103                         if (m3 == csrc) continue;
7104                         if (m3->mc_pg[csrc->mc_top] == mp && m3->mc_ki[csrc->mc_top] ==
7105                                 csrc->mc_ki[csrc->mc_top]) {
7106                                 m3->mc_pg[csrc->mc_top] = cdst->mc_pg[cdst->mc_top];
7107                                 m3->mc_ki[csrc->mc_top] = cdst->mc_ki[cdst->mc_top];
7108                         }
7109                 }
7110         }
7111
7112         /* Update the parent separators.
7113          */
7114         if (csrc->mc_ki[csrc->mc_top] == 0) {
7115                 if (csrc->mc_ki[csrc->mc_top-1] != 0) {
7116                         if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7117                                 key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], 0, key.mv_size);
7118                         } else {
7119                                 srcnode = NODEPTR(csrc->mc_pg[csrc->mc_top], 0);
7120                                 key.mv_size = NODEKSZ(srcnode);
7121                                 key.mv_data = NODEKEY(srcnode);
7122                         }
7123                         DPRINTF(("update separator for source page %"Z"u to [%s]",
7124                                 csrc->mc_pg[csrc->mc_top]->mp_pgno, DKEY(&key)));
7125                         mdb_cursor_copy(csrc, &mn);
7126                         mn.mc_snum--;
7127                         mn.mc_top--;
7128                         if ((rc = mdb_update_key(&mn, &key)) != MDB_SUCCESS)
7129                                 return rc;
7130                 }
7131                 if (IS_BRANCH(csrc->mc_pg[csrc->mc_top])) {
7132                         MDB_val  nullkey;
7133                         indx_t  ix = csrc->mc_ki[csrc->mc_top];
7134                         nullkey.mv_size = 0;
7135                         csrc->mc_ki[csrc->mc_top] = 0;
7136                         rc = mdb_update_key(csrc, &nullkey);
7137                         csrc->mc_ki[csrc->mc_top] = ix;
7138                         mdb_cassert(csrc, rc == MDB_SUCCESS);
7139                 }
7140         }
7141
7142         if (cdst->mc_ki[cdst->mc_top] == 0) {
7143                 if (cdst->mc_ki[cdst->mc_top-1] != 0) {
7144                         if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7145                                 key.mv_data = LEAF2KEY(cdst->mc_pg[cdst->mc_top], 0, key.mv_size);
7146                         } else {
7147                                 srcnode = NODEPTR(cdst->mc_pg[cdst->mc_top], 0);
7148                                 key.mv_size = NODEKSZ(srcnode);
7149                                 key.mv_data = NODEKEY(srcnode);
7150                         }
7151                         DPRINTF(("update separator for destination page %"Z"u to [%s]",
7152                                 cdst->mc_pg[cdst->mc_top]->mp_pgno, DKEY(&key)));
7153                         mdb_cursor_copy(cdst, &mn);
7154                         mn.mc_snum--;
7155                         mn.mc_top--;
7156                         if ((rc = mdb_update_key(&mn, &key)) != MDB_SUCCESS)
7157                                 return rc;
7158                 }
7159                 if (IS_BRANCH(cdst->mc_pg[cdst->mc_top])) {
7160                         MDB_val  nullkey;
7161                         indx_t  ix = cdst->mc_ki[cdst->mc_top];
7162                         nullkey.mv_size = 0;
7163                         cdst->mc_ki[cdst->mc_top] = 0;
7164                         rc = mdb_update_key(cdst, &nullkey);
7165                         cdst->mc_ki[cdst->mc_top] = ix;
7166                         mdb_cassert(csrc, rc == MDB_SUCCESS);
7167                 }
7168         }
7169
7170         return MDB_SUCCESS;
7171 }
7172
7173 /** Merge one page into another.
7174  *  The nodes from the page pointed to by \b csrc will
7175  *      be copied to the page pointed to by \b cdst and then
7176  *      the \b csrc page will be freed.
7177  * @param[in] csrc Cursor pointing to the source page.
7178  * @param[in] cdst Cursor pointing to the destination page.
7179  * @return 0 on success, non-zero on failure.
7180  */
7181 static int
7182 mdb_page_merge(MDB_cursor *csrc, MDB_cursor *cdst)
7183 {
7184         int                      rc;
7185         indx_t                   i, j;
7186         MDB_node                *srcnode;
7187         MDB_val          key, data;
7188         unsigned        nkeys;
7189
7190         DPRINTF(("merging page %"Z"u into %"Z"u", csrc->mc_pg[csrc->mc_top]->mp_pgno,
7191                 cdst->mc_pg[cdst->mc_top]->mp_pgno));
7192
7193         mdb_cassert(csrc, csrc->mc_snum > 1);   /* can't merge root page */
7194         mdb_cassert(csrc, cdst->mc_snum > 1);
7195
7196         /* Mark dst as dirty. */
7197         if ((rc = mdb_page_touch(cdst)))
7198                 return rc;
7199
7200         /* Move all nodes from src to dst.
7201          */
7202         j = nkeys = NUMKEYS(cdst->mc_pg[cdst->mc_top]);
7203         if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7204                 key.mv_size = csrc->mc_db->md_pad;
7205                 key.mv_data = METADATA(csrc->mc_pg[csrc->mc_top]);
7206                 for (i = 0; i < NUMKEYS(csrc->mc_pg[csrc->mc_top]); i++, j++) {
7207                         rc = mdb_node_add(cdst, j, &key, NULL, 0, 0);
7208                         if (rc != MDB_SUCCESS)
7209                                 return rc;
7210                         key.mv_data = (char *)key.mv_data + key.mv_size;
7211                 }
7212         } else {
7213                 for (i = 0; i < NUMKEYS(csrc->mc_pg[csrc->mc_top]); i++, j++) {
7214                         srcnode = NODEPTR(csrc->mc_pg[csrc->mc_top], i);
7215                         if (i == 0 && IS_BRANCH(csrc->mc_pg[csrc->mc_top])) {
7216                                 unsigned int snum = csrc->mc_snum;
7217                                 MDB_node *s2;
7218                                 /* must find the lowest key below src */
7219                                 rc = mdb_page_search_lowest(csrc);
7220                                 if (rc)
7221                                         return rc;
7222                                 if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7223                                         key.mv_size = csrc->mc_db->md_pad;
7224                                         key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], 0, key.mv_size);
7225                                 } else {
7226                                         s2 = NODEPTR(csrc->mc_pg[csrc->mc_top], 0);
7227                                         key.mv_size = NODEKSZ(s2);
7228                                         key.mv_data = NODEKEY(s2);
7229                                 }
7230                                 csrc->mc_snum = snum--;
7231                                 csrc->mc_top = snum;
7232                         } else {
7233                                 key.mv_size = srcnode->mn_ksize;
7234                                 key.mv_data = NODEKEY(srcnode);
7235                         }
7236
7237                         data.mv_size = NODEDSZ(srcnode);
7238                         data.mv_data = NODEDATA(srcnode);
7239                         rc = mdb_node_add(cdst, j, &key, &data, NODEPGNO(srcnode), srcnode->mn_flags);
7240                         if (rc != MDB_SUCCESS)
7241                                 return rc;
7242                 }
7243         }
7244
7245         DPRINTF(("dst page %"Z"u now has %u keys (%.1f%% filled)",
7246             cdst->mc_pg[cdst->mc_top]->mp_pgno, NUMKEYS(cdst->mc_pg[cdst->mc_top]),
7247                 (float)PAGEFILL(cdst->mc_txn->mt_env, cdst->mc_pg[cdst->mc_top]) / 10));
7248
7249         /* Unlink the src page from parent and add to free list.
7250          */
7251         csrc->mc_top--;
7252         mdb_node_del(csrc, 0);
7253         if (csrc->mc_ki[csrc->mc_top] == 0) {
7254                 key.mv_size = 0;
7255                 rc = mdb_update_key(csrc, &key);
7256                 if (rc) {
7257                         csrc->mc_top++;
7258                         return rc;
7259                 }
7260         }
7261         csrc->mc_top++;
7262
7263         rc = mdb_midl_append(&csrc->mc_txn->mt_free_pgs,
7264                 csrc->mc_pg[csrc->mc_top]->mp_pgno);
7265         if (rc)
7266                 return rc;
7267         if (IS_LEAF(csrc->mc_pg[csrc->mc_top]))
7268                 csrc->mc_db->md_leaf_pages--;
7269         else
7270                 csrc->mc_db->md_branch_pages--;
7271         {
7272                 /* Adjust other cursors pointing to mp */
7273                 MDB_cursor *m2, *m3;
7274                 MDB_dbi dbi = csrc->mc_dbi;
7275                 MDB_page *mp = cdst->mc_pg[cdst->mc_top];
7276
7277                 for (m2 = csrc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7278                         if (csrc->mc_flags & C_SUB)
7279                                 m3 = &m2->mc_xcursor->mx_cursor;
7280                         else
7281                                 m3 = m2;
7282                         if (m3 == csrc) continue;
7283                         if (m3->mc_snum < csrc->mc_snum) continue;
7284                         if (m3->mc_pg[csrc->mc_top] == csrc->mc_pg[csrc->mc_top]) {
7285                                 m3->mc_pg[csrc->mc_top] = mp;
7286                                 m3->mc_ki[csrc->mc_top] += nkeys;
7287                         }
7288                 }
7289         }
7290         {
7291                 unsigned int snum = cdst->mc_snum;
7292                 uint16_t depth = cdst->mc_db->md_depth;
7293                 mdb_cursor_pop(cdst);
7294                 rc = mdb_rebalance(cdst);
7295                 /* Did the tree shrink? */
7296                 if (depth > cdst->mc_db->md_depth)
7297                         snum--;
7298                 cdst->mc_snum = snum;
7299                 cdst->mc_top = snum-1;
7300         }
7301         return rc;
7302 }
7303
7304 /** Copy the contents of a cursor.
7305  * @param[in] csrc The cursor to copy from.
7306  * @param[out] cdst The cursor to copy to.
7307  */
7308 static void
7309 mdb_cursor_copy(const MDB_cursor *csrc, MDB_cursor *cdst)
7310 {
7311         unsigned int i;
7312
7313         cdst->mc_txn = csrc->mc_txn;
7314         cdst->mc_dbi = csrc->mc_dbi;
7315         cdst->mc_db  = csrc->mc_db;
7316         cdst->mc_dbx = csrc->mc_dbx;
7317         cdst->mc_snum = csrc->mc_snum;
7318         cdst->mc_top = csrc->mc_top;
7319         cdst->mc_flags = csrc->mc_flags;
7320
7321         for (i=0; i<csrc->mc_snum; i++) {
7322                 cdst->mc_pg[i] = csrc->mc_pg[i];
7323                 cdst->mc_ki[i] = csrc->mc_ki[i];
7324         }
7325 }
7326
7327 /** Rebalance the tree after a delete operation.
7328  * @param[in] mc Cursor pointing to the page where rebalancing
7329  * should begin.
7330  * @return 0 on success, non-zero on failure.
7331  */
7332 static int
7333 mdb_rebalance(MDB_cursor *mc)
7334 {
7335         MDB_node        *node;
7336         int rc;
7337         unsigned int ptop, minkeys;
7338         MDB_cursor      mn;
7339         indx_t oldki;
7340
7341         minkeys = 1 + (IS_BRANCH(mc->mc_pg[mc->mc_top]));
7342         DPRINTF(("rebalancing %s page %"Z"u (has %u keys, %.1f%% full)",
7343             IS_LEAF(mc->mc_pg[mc->mc_top]) ? "leaf" : "branch",
7344             mdb_dbg_pgno(mc->mc_pg[mc->mc_top]), NUMKEYS(mc->mc_pg[mc->mc_top]),
7345                 (float)PAGEFILL(mc->mc_txn->mt_env, mc->mc_pg[mc->mc_top]) / 10));
7346
7347         if (PAGEFILL(mc->mc_txn->mt_env, mc->mc_pg[mc->mc_top]) >= FILL_THRESHOLD &&
7348                 NUMKEYS(mc->mc_pg[mc->mc_top]) >= minkeys) {
7349                 DPRINTF(("no need to rebalance page %"Z"u, above fill threshold",
7350                     mdb_dbg_pgno(mc->mc_pg[mc->mc_top])));
7351                 return MDB_SUCCESS;
7352         }
7353
7354         if (mc->mc_snum < 2) {
7355                 MDB_page *mp = mc->mc_pg[0];
7356                 if (IS_SUBP(mp)) {
7357                         DPUTS("Can't rebalance a subpage, ignoring");
7358                         return MDB_SUCCESS;
7359                 }
7360                 if (NUMKEYS(mp) == 0) {
7361                         DPUTS("tree is completely empty");
7362                         mc->mc_db->md_root = P_INVALID;
7363                         mc->mc_db->md_depth = 0;
7364                         mc->mc_db->md_leaf_pages = 0;
7365                         rc = mdb_midl_append(&mc->mc_txn->mt_free_pgs, mp->mp_pgno);
7366                         if (rc)
7367                                 return rc;
7368                         /* Adjust cursors pointing to mp */
7369                         mc->mc_snum = 0;
7370                         mc->mc_top = 0;
7371                         mc->mc_flags &= ~C_INITIALIZED;
7372                         {
7373                                 MDB_cursor *m2, *m3;
7374                                 MDB_dbi dbi = mc->mc_dbi;
7375
7376                                 for (m2 = mc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7377                                         if (mc->mc_flags & C_SUB)
7378                                                 m3 = &m2->mc_xcursor->mx_cursor;
7379                                         else
7380                                                 m3 = m2;
7381                                         if (m3->mc_snum < mc->mc_snum) continue;
7382                                         if (m3->mc_pg[0] == mp) {
7383                                                 m3->mc_snum = 0;
7384                                                 m3->mc_top = 0;
7385                                                 m3->mc_flags &= ~C_INITIALIZED;
7386                                         }
7387                                 }
7388                         }
7389                 } else if (IS_BRANCH(mp) && NUMKEYS(mp) == 1) {
7390                         int i;
7391                         DPUTS("collapsing root page!");
7392                         rc = mdb_midl_append(&mc->mc_txn->mt_free_pgs, mp->mp_pgno);
7393                         if (rc)
7394                                 return rc;
7395                         mc->mc_db->md_root = NODEPGNO(NODEPTR(mp, 0));
7396                         rc = mdb_page_get(mc->mc_txn,mc->mc_db->md_root,&mc->mc_pg[0],NULL);
7397                         if (rc)
7398                                 return rc;
7399                         mc->mc_db->md_depth--;
7400                         mc->mc_db->md_branch_pages--;
7401                         mc->mc_ki[0] = mc->mc_ki[1];
7402                         for (i = 1; i<mc->mc_db->md_depth; i++) {
7403                                 mc->mc_pg[i] = mc->mc_pg[i+1];
7404                                 mc->mc_ki[i] = mc->mc_ki[i+1];
7405                         }
7406                         {
7407                                 /* Adjust other cursors pointing to mp */
7408                                 MDB_cursor *m2, *m3;
7409                                 MDB_dbi dbi = mc->mc_dbi;
7410
7411                                 for (m2 = mc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7412                                         if (mc->mc_flags & C_SUB)
7413                                                 m3 = &m2->mc_xcursor->mx_cursor;
7414                                         else
7415                                                 m3 = m2;
7416                                         if (m3 == mc || m3->mc_snum < mc->mc_snum) continue;
7417                                         if (m3->mc_pg[0] == mp) {
7418                                                 m3->mc_snum--;
7419                                                 m3->mc_top--;
7420                                                 for (i=0; i<m3->mc_snum; i++) {
7421                                                         m3->mc_pg[i] = m3->mc_pg[i+1];
7422                                                         m3->mc_ki[i] = m3->mc_ki[i+1];
7423                                                 }
7424                                         }
7425                                 }
7426                         }
7427                 } else
7428                         DPUTS("root page doesn't need rebalancing");
7429                 return MDB_SUCCESS;
7430         }
7431
7432         /* The parent (branch page) must have at least 2 pointers,
7433          * otherwise the tree is invalid.
7434          */
7435         ptop = mc->mc_top-1;
7436         mdb_cassert(mc, NUMKEYS(mc->mc_pg[ptop]) > 1);
7437
7438         /* Leaf page fill factor is below the threshold.
7439          * Try to move keys from left or right neighbor, or
7440          * merge with a neighbor page.
7441          */
7442
7443         /* Find neighbors.
7444          */
7445         mdb_cursor_copy(mc, &mn);
7446         mn.mc_xcursor = NULL;
7447
7448         oldki = mc->mc_ki[mc->mc_top];
7449         if (mc->mc_ki[ptop] == 0) {
7450                 /* We're the leftmost leaf in our parent.
7451                  */
7452                 DPUTS("reading right neighbor");
7453                 mn.mc_ki[ptop]++;
7454                 node = NODEPTR(mc->mc_pg[ptop], mn.mc_ki[ptop]);
7455                 rc = mdb_page_get(mc->mc_txn,NODEPGNO(node),&mn.mc_pg[mn.mc_top],NULL);
7456                 if (rc)
7457                         return rc;
7458                 mn.mc_ki[mn.mc_top] = 0;
7459                 mc->mc_ki[mc->mc_top] = NUMKEYS(mc->mc_pg[mc->mc_top]);
7460         } else {
7461                 /* There is at least one neighbor to the left.
7462                  */
7463                 DPUTS("reading left neighbor");
7464                 mn.mc_ki[ptop]--;
7465                 node = NODEPTR(mc->mc_pg[ptop], mn.mc_ki[ptop]);
7466                 rc = mdb_page_get(mc->mc_txn,NODEPGNO(node),&mn.mc_pg[mn.mc_top],NULL);
7467                 if (rc)
7468                         return rc;
7469                 mn.mc_ki[mn.mc_top] = NUMKEYS(mn.mc_pg[mn.mc_top]) - 1;
7470                 mc->mc_ki[mc->mc_top] = 0;
7471         }
7472
7473         DPRINTF(("found neighbor page %"Z"u (%u keys, %.1f%% full)",
7474             mn.mc_pg[mn.mc_top]->mp_pgno, NUMKEYS(mn.mc_pg[mn.mc_top]),
7475                 (float)PAGEFILL(mc->mc_txn->mt_env, mn.mc_pg[mn.mc_top]) / 10));
7476
7477         /* If the neighbor page is above threshold and has enough keys,
7478          * move one key from it. Otherwise we should try to merge them.
7479          * (A branch page must never have less than 2 keys.)
7480          */
7481         minkeys = 1 + (IS_BRANCH(mn.mc_pg[mn.mc_top]));
7482         if (PAGEFILL(mc->mc_txn->mt_env, mn.mc_pg[mn.mc_top]) >= FILL_THRESHOLD && NUMKEYS(mn.mc_pg[mn.mc_top]) > minkeys) {
7483                 rc = mdb_node_move(&mn, mc);
7484                 if (mc->mc_ki[ptop]) {
7485                         oldki++;
7486                 }
7487         } else {
7488                 if (mc->mc_ki[ptop] == 0) {
7489                         rc = mdb_page_merge(&mn, mc);
7490                 } else {
7491                         oldki += NUMKEYS(mn.mc_pg[mn.mc_top]);
7492                         mn.mc_ki[mn.mc_top] += mc->mc_ki[mn.mc_top] + 1;
7493                         rc = mdb_page_merge(mc, &mn);
7494                         mdb_cursor_copy(&mn, mc);
7495                 }
7496                 mc->mc_flags &= ~C_EOF;
7497         }
7498         mc->mc_ki[mc->mc_top] = oldki;
7499         return rc;
7500 }
7501
7502 /** Complete a delete operation started by #mdb_cursor_del(). */
7503 static int
7504 mdb_cursor_del0(MDB_cursor *mc)
7505 {
7506         int rc;
7507         MDB_page *mp;
7508         indx_t ki;
7509         unsigned int nkeys;
7510
7511         ki = mc->mc_ki[mc->mc_top];
7512         mdb_node_del(mc, mc->mc_db->md_pad);
7513         mc->mc_db->md_entries--;
7514         rc = mdb_rebalance(mc);
7515
7516         if (rc == MDB_SUCCESS) {
7517                 MDB_cursor *m2, *m3;
7518                 MDB_dbi dbi = mc->mc_dbi;
7519
7520                 mp = mc->mc_pg[mc->mc_top];
7521                 nkeys = NUMKEYS(mp);
7522
7523                 /* if mc points past last node in page, find next sibling */
7524                 if (mc->mc_ki[mc->mc_top] >= nkeys) {
7525                         rc = mdb_cursor_sibling(mc, 1);
7526                         if (rc == MDB_NOTFOUND)
7527                                 rc = MDB_SUCCESS;
7528                 }
7529
7530                 /* Adjust other cursors pointing to mp */
7531                 for (m2 = mc->mc_txn->mt_cursors[dbi]; !rc && m2; m2=m2->mc_next) {
7532                         m3 = (mc->mc_flags & C_SUB) ? &m2->mc_xcursor->mx_cursor : m2;
7533                         if (! (m2->mc_flags & m3->mc_flags & C_INITIALIZED))
7534                                 continue;
7535                         if (m3 == mc || m3->mc_snum < mc->mc_snum)
7536                                 continue;
7537                         if (m3->mc_pg[mc->mc_top] == mp) {
7538                                 if (m3->mc_ki[mc->mc_top] >= ki) {
7539                                         m3->mc_flags |= C_DEL;
7540                                         if (m3->mc_ki[mc->mc_top] > ki)
7541                                                 m3->mc_ki[mc->mc_top]--;
7542                                 }
7543                                 if (m3->mc_ki[mc->mc_top] >= nkeys) {
7544                                         rc = mdb_cursor_sibling(m3, 1);
7545                                         if (rc == MDB_NOTFOUND)
7546                                                 rc = MDB_SUCCESS;
7547                                 }
7548                         }
7549                 }
7550                 mc->mc_flags |= C_DEL;
7551         }
7552
7553         if (rc)
7554                 mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
7555         return rc;
7556 }
7557
7558 int
7559 mdb_del(MDB_txn *txn, MDB_dbi dbi,
7560     MDB_val *key, MDB_val *data)
7561 {
7562         if (!key || dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
7563                 return EINVAL;
7564
7565         if (txn->mt_flags & (MDB_TXN_RDONLY|MDB_TXN_ERROR))
7566                 return (txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
7567
7568         if (!F_ISSET(txn->mt_dbs[dbi].md_flags, MDB_DUPSORT)) {
7569                 /* must ignore any data */
7570                 data = NULL;
7571         }
7572
7573         return mdb_del0(txn, dbi, key, data, 0);
7574 }
7575
7576 static int
7577 mdb_del0(MDB_txn *txn, MDB_dbi dbi,
7578         MDB_val *key, MDB_val *data, unsigned flags)
7579 {
7580         MDB_cursor mc;
7581         MDB_xcursor mx;
7582         MDB_cursor_op op;
7583         MDB_val rdata, *xdata;
7584         int              rc, exact = 0;
7585         DKBUF;
7586
7587         DPRINTF(("====> delete db %u key [%s]", dbi, DKEY(key)));
7588
7589         mdb_cursor_init(&mc, txn, dbi, &mx);
7590
7591         if (data) {
7592                 op = MDB_GET_BOTH;
7593                 rdata = *data;
7594                 xdata = &rdata;
7595         } else {
7596                 op = MDB_SET;
7597                 xdata = NULL;
7598                 flags |= MDB_NODUPDATA;
7599         }
7600         rc = mdb_cursor_set(&mc, key, xdata, op, &exact);
7601         if (rc == 0) {
7602                 /* let mdb_page_split know about this cursor if needed:
7603                  * delete will trigger a rebalance; if it needs to move
7604                  * a node from one page to another, it will have to
7605                  * update the parent's separator key(s). If the new sepkey
7606                  * is larger than the current one, the parent page may
7607                  * run out of space, triggering a split. We need this
7608                  * cursor to be consistent until the end of the rebalance.
7609                  */
7610                 mc.mc_flags |= C_UNTRACK;
7611                 mc.mc_next = txn->mt_cursors[dbi];
7612                 txn->mt_cursors[dbi] = &mc;
7613                 rc = mdb_cursor_del(&mc, flags);
7614                 txn->mt_cursors[dbi] = mc.mc_next;
7615         }
7616         return rc;
7617 }
7618
7619 /** Split a page and insert a new node.
7620  * @param[in,out] mc Cursor pointing to the page and desired insertion index.
7621  * The cursor will be updated to point to the actual page and index where
7622  * the node got inserted after the split.
7623  * @param[in] newkey The key for the newly inserted node.
7624  * @param[in] newdata The data for the newly inserted node.
7625  * @param[in] newpgno The page number, if the new node is a branch node.
7626  * @param[in] nflags The #NODE_ADD_FLAGS for the new node.
7627  * @return 0 on success, non-zero on failure.
7628  */
7629 static int
7630 mdb_page_split(MDB_cursor *mc, MDB_val *newkey, MDB_val *newdata, pgno_t newpgno,
7631         unsigned int nflags)
7632 {
7633         unsigned int flags;
7634         int              rc = MDB_SUCCESS, new_root = 0, did_split = 0;
7635         indx_t           newindx;
7636         pgno_t           pgno = 0;
7637         int      i, j, split_indx, nkeys, pmax;
7638         MDB_env         *env = mc->mc_txn->mt_env;
7639         MDB_node        *node;
7640         MDB_val  sepkey, rkey, xdata, *rdata = &xdata;
7641         MDB_page        *copy = NULL;
7642         MDB_page        *mp, *rp, *pp;
7643         int ptop;
7644         MDB_cursor      mn;
7645         DKBUF;
7646
7647         mp = mc->mc_pg[mc->mc_top];
7648         newindx = mc->mc_ki[mc->mc_top];
7649         nkeys = NUMKEYS(mp);
7650
7651         DPRINTF(("-----> splitting %s page %"Z"u and adding [%s] at index %i/%i",
7652             IS_LEAF(mp) ? "leaf" : "branch", mp->mp_pgno,
7653             DKEY(newkey), mc->mc_ki[mc->mc_top], nkeys));
7654
7655         /* Create a right sibling. */
7656         if ((rc = mdb_page_new(mc, mp->mp_flags, 1, &rp)))
7657                 return rc;
7658         DPRINTF(("new right sibling: page %"Z"u", rp->mp_pgno));
7659
7660         if (mc->mc_snum < 2) {
7661                 if ((rc = mdb_page_new(mc, P_BRANCH, 1, &pp)))
7662                         goto done;
7663                 /* shift current top to make room for new parent */
7664                 mc->mc_pg[1] = mc->mc_pg[0];
7665                 mc->mc_ki[1] = mc->mc_ki[0];
7666                 mc->mc_pg[0] = pp;
7667                 mc->mc_ki[0] = 0;
7668                 mc->mc_db->md_root = pp->mp_pgno;
7669                 DPRINTF(("root split! new root = %"Z"u", pp->mp_pgno));
7670                 mc->mc_db->md_depth++;
7671                 new_root = 1;
7672
7673                 /* Add left (implicit) pointer. */
7674                 if ((rc = mdb_node_add(mc, 0, NULL, NULL, mp->mp_pgno, 0)) != MDB_SUCCESS) {
7675                         /* undo the pre-push */
7676                         mc->mc_pg[0] = mc->mc_pg[1];
7677                         mc->mc_ki[0] = mc->mc_ki[1];
7678                         mc->mc_db->md_root = mp->mp_pgno;
7679                         mc->mc_db->md_depth--;
7680                         goto done;
7681                 }
7682                 mc->mc_snum = 2;
7683                 mc->mc_top = 1;
7684                 ptop = 0;
7685         } else {
7686                 ptop = mc->mc_top-1;
7687                 DPRINTF(("parent branch page is %"Z"u", mc->mc_pg[ptop]->mp_pgno));
7688         }
7689
7690         mc->mc_flags |= C_SPLITTING;
7691         mdb_cursor_copy(mc, &mn);
7692         mn.mc_pg[mn.mc_top] = rp;
7693         mn.mc_ki[ptop] = mc->mc_ki[ptop]+1;
7694
7695         if (nflags & MDB_APPEND) {
7696                 mn.mc_ki[mn.mc_top] = 0;
7697                 sepkey = *newkey;
7698                 split_indx = newindx;
7699                 nkeys = 0;
7700         } else {
7701
7702                 split_indx = (nkeys+1) / 2;
7703
7704                 if (IS_LEAF2(rp)) {
7705                         char *split, *ins;
7706                         int x;
7707                         unsigned int lsize, rsize, ksize;
7708                         /* Move half of the keys to the right sibling */
7709                         x = mc->mc_ki[mc->mc_top] - split_indx;
7710                         ksize = mc->mc_db->md_pad;
7711                         split = LEAF2KEY(mp, split_indx, ksize);
7712                         rsize = (nkeys - split_indx) * ksize;
7713                         lsize = (nkeys - split_indx) * sizeof(indx_t);
7714                         mp->mp_lower -= lsize;
7715                         rp->mp_lower += lsize;
7716                         mp->mp_upper += rsize - lsize;
7717                         rp->mp_upper -= rsize - lsize;
7718                         sepkey.mv_size = ksize;
7719                         if (newindx == split_indx) {
7720                                 sepkey.mv_data = newkey->mv_data;
7721                         } else {
7722                                 sepkey.mv_data = split;
7723                         }
7724                         if (x<0) {
7725                                 ins = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], ksize);
7726                                 memcpy(rp->mp_ptrs, split, rsize);
7727                                 sepkey.mv_data = rp->mp_ptrs;
7728                                 memmove(ins+ksize, ins, (split_indx - mc->mc_ki[mc->mc_top]) * ksize);
7729                                 memcpy(ins, newkey->mv_data, ksize);
7730                                 mp->mp_lower += sizeof(indx_t);
7731                                 mp->mp_upper -= ksize - sizeof(indx_t);
7732                         } else {
7733                                 if (x)
7734                                         memcpy(rp->mp_ptrs, split, x * ksize);
7735                                 ins = LEAF2KEY(rp, x, ksize);
7736                                 memcpy(ins, newkey->mv_data, ksize);
7737                                 memcpy(ins+ksize, split + x * ksize, rsize - x * ksize);
7738                                 rp->mp_lower += sizeof(indx_t);
7739                                 rp->mp_upper -= ksize - sizeof(indx_t);
7740                                 mc->mc_ki[mc->mc_top] = x;
7741                                 mc->mc_pg[mc->mc_top] = rp;
7742                         }
7743                 } else {
7744                         int psize, nsize, k;
7745                         /* Maximum free space in an empty page */
7746                         pmax = env->me_psize - PAGEHDRSZ;
7747                         if (IS_LEAF(mp))
7748                                 nsize = mdb_leaf_size(env, newkey, newdata);
7749                         else
7750                                 nsize = mdb_branch_size(env, newkey);
7751                         nsize = EVEN(nsize);
7752
7753                         /* grab a page to hold a temporary copy */
7754                         copy = mdb_page_malloc(mc->mc_txn, 1);
7755                         if (copy == NULL) {
7756                                 rc = ENOMEM;
7757                                 goto done;
7758                         }
7759                         copy->mp_pgno  = mp->mp_pgno;
7760                         copy->mp_flags = mp->mp_flags;
7761                         copy->mp_lower = PAGEHDRSZ;
7762                         copy->mp_upper = env->me_psize;
7763
7764                         /* prepare to insert */
7765                         for (i=0, j=0; i<nkeys; i++) {
7766                                 if (i == newindx) {
7767                                         copy->mp_ptrs[j++] = 0;
7768                                 }
7769                                 copy->mp_ptrs[j++] = mp->mp_ptrs[i];
7770                         }
7771
7772                         /* When items are relatively large the split point needs
7773                          * to be checked, because being off-by-one will make the
7774                          * difference between success or failure in mdb_node_add.
7775                          *
7776                          * It's also relevant if a page happens to be laid out
7777                          * such that one half of its nodes are all "small" and
7778                          * the other half of its nodes are "large." If the new
7779                          * item is also "large" and falls on the half with
7780                          * "large" nodes, it also may not fit.
7781                          *
7782                          * As a final tweak, if the new item goes on the last
7783                          * spot on the page (and thus, onto the new page), bias
7784                          * the split so the new page is emptier than the old page.
7785                          * This yields better packing during sequential inserts.
7786                          */
7787                         if (nkeys < 20 || nsize > pmax/16 || newindx >= nkeys) {
7788                                 /* Find split point */
7789                                 psize = 0;
7790                                 if (newindx <= split_indx || newindx >= nkeys) {
7791                                         i = 0; j = 1;
7792                                         k = newindx >= nkeys ? nkeys : split_indx+2;
7793                                 } else {
7794                                         i = nkeys; j = -1;
7795                                         k = split_indx-1;
7796                                 }
7797                                 for (; i!=k; i+=j) {
7798                                         if (i == newindx) {
7799                                                 psize += nsize;
7800                                                 node = NULL;
7801                                         } else {
7802                                                 node = (MDB_node *)((char *)mp + copy->mp_ptrs[i]);
7803                                                 psize += NODESIZE + NODEKSZ(node) + sizeof(indx_t);
7804                                                 if (IS_LEAF(mp)) {
7805                                                         if (F_ISSET(node->mn_flags, F_BIGDATA))
7806                                                                 psize += sizeof(pgno_t);
7807                                                         else
7808                                                                 psize += NODEDSZ(node);
7809                                                 }
7810                                                 psize = EVEN(psize);
7811                                         }
7812                                         if (psize > pmax || i == k-j) {
7813                                                 split_indx = i + (j<0);
7814                                                 break;
7815                                         }
7816                                 }
7817                         }
7818                         if (split_indx == newindx) {
7819                                 sepkey.mv_size = newkey->mv_size;
7820                                 sepkey.mv_data = newkey->mv_data;
7821                         } else {
7822                                 node = (MDB_node *)((char *)mp + copy->mp_ptrs[split_indx]);
7823                                 sepkey.mv_size = node->mn_ksize;
7824                                 sepkey.mv_data = NODEKEY(node);
7825                         }
7826                 }
7827         }
7828
7829         DPRINTF(("separator is %d [%s]", split_indx, DKEY(&sepkey)));
7830
7831         /* Copy separator key to the parent.
7832          */
7833         if (SIZELEFT(mn.mc_pg[ptop]) < mdb_branch_size(env, &sepkey)) {
7834                 mn.mc_snum--;
7835                 mn.mc_top--;
7836                 did_split = 1;
7837                 rc = mdb_page_split(&mn, &sepkey, NULL, rp->mp_pgno, 0);
7838                 if (rc)
7839                         goto done;
7840
7841                 /* root split? */
7842                 if (mn.mc_snum == mc->mc_snum) {
7843                         mc->mc_pg[mc->mc_snum] = mc->mc_pg[mc->mc_top];
7844                         mc->mc_ki[mc->mc_snum] = mc->mc_ki[mc->mc_top];
7845                         mc->mc_pg[mc->mc_top] = mc->mc_pg[ptop];
7846                         mc->mc_ki[mc->mc_top] = mc->mc_ki[ptop];
7847                         mc->mc_snum++;
7848                         mc->mc_top++;
7849                         ptop++;
7850                 }
7851                 /* Right page might now have changed parent.
7852                  * Check if left page also changed parent.
7853                  */
7854                 if (mn.mc_pg[ptop] != mc->mc_pg[ptop] &&
7855                     mc->mc_ki[ptop] >= NUMKEYS(mc->mc_pg[ptop])) {
7856                         for (i=0; i<ptop; i++) {
7857                                 mc->mc_pg[i] = mn.mc_pg[i];
7858                                 mc->mc_ki[i] = mn.mc_ki[i];
7859                         }
7860                         mc->mc_pg[ptop] = mn.mc_pg[ptop];
7861                         if (mn.mc_ki[ptop]) {
7862                                 mc->mc_ki[ptop] = mn.mc_ki[ptop] - 1;
7863                         } else {
7864                                 /* find right page's left sibling */
7865                                 mc->mc_ki[ptop] = mn.mc_ki[ptop];
7866                                 mdb_cursor_sibling(mc, 0);
7867                         }
7868                 }
7869         } else {
7870                 mn.mc_top--;
7871                 rc = mdb_node_add(&mn, mn.mc_ki[ptop], &sepkey, NULL, rp->mp_pgno, 0);
7872                 mn.mc_top++;
7873         }
7874         mc->mc_flags ^= C_SPLITTING;
7875         if (rc != MDB_SUCCESS) {
7876                 goto done;
7877         }
7878         if (nflags & MDB_APPEND) {
7879                 mc->mc_pg[mc->mc_top] = rp;
7880                 mc->mc_ki[mc->mc_top] = 0;
7881                 rc = mdb_node_add(mc, 0, newkey, newdata, newpgno, nflags);
7882                 if (rc)
7883                         goto done;
7884                 for (i=0; i<mc->mc_top; i++)
7885                         mc->mc_ki[i] = mn.mc_ki[i];
7886         } else if (!IS_LEAF2(mp)) {
7887                 /* Move nodes */
7888                 mc->mc_pg[mc->mc_top] = rp;
7889                 i = split_indx;
7890                 j = 0;
7891                 do {
7892                         if (i == newindx) {
7893                                 rkey.mv_data = newkey->mv_data;
7894                                 rkey.mv_size = newkey->mv_size;
7895                                 if (IS_LEAF(mp)) {
7896                                         rdata = newdata;
7897                                 } else
7898                                         pgno = newpgno;
7899                                 flags = nflags;
7900                                 /* Update index for the new key. */
7901                                 mc->mc_ki[mc->mc_top] = j;
7902                         } else {
7903                                 node = (MDB_node *)((char *)mp + copy->mp_ptrs[i]);
7904                                 rkey.mv_data = NODEKEY(node);
7905                                 rkey.mv_size = node->mn_ksize;
7906                                 if (IS_LEAF(mp)) {
7907                                         xdata.mv_data = NODEDATA(node);
7908                                         xdata.mv_size = NODEDSZ(node);
7909                                         rdata = &xdata;
7910                                 } else
7911                                         pgno = NODEPGNO(node);
7912                                 flags = node->mn_flags;
7913                         }
7914
7915                         if (!IS_LEAF(mp) && j == 0) {
7916                                 /* First branch index doesn't need key data. */
7917                                 rkey.mv_size = 0;
7918                         }
7919
7920                         rc = mdb_node_add(mc, j, &rkey, rdata, pgno, flags);
7921                         if (rc)
7922                                 goto done;
7923                         if (i == nkeys) {
7924                                 i = 0;
7925                                 j = 0;
7926                                 mc->mc_pg[mc->mc_top] = copy;
7927                         } else {
7928                                 i++;
7929                                 j++;
7930                         }
7931                 } while (i != split_indx);
7932
7933                 nkeys = NUMKEYS(copy);
7934                 for (i=0; i<nkeys; i++)
7935                         mp->mp_ptrs[i] = copy->mp_ptrs[i];
7936                 mp->mp_lower = copy->mp_lower;
7937                 mp->mp_upper = copy->mp_upper;
7938                 memcpy(NODEPTR(mp, nkeys-1), NODEPTR(copy, nkeys-1),
7939                         env->me_psize - copy->mp_upper);
7940
7941                 /* reset back to original page */
7942                 if (newindx < split_indx) {
7943                         mc->mc_pg[mc->mc_top] = mp;
7944                         if (nflags & MDB_RESERVE) {
7945                                 node = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
7946                                 if (!(node->mn_flags & F_BIGDATA))
7947                                         newdata->mv_data = NODEDATA(node);
7948                         }
7949                 } else {
7950                         mc->mc_pg[mc->mc_top] = rp;
7951                         mc->mc_ki[ptop]++;
7952                         /* Make sure mc_ki is still valid.
7953                          */
7954                         if (mn.mc_pg[ptop] != mc->mc_pg[ptop] &&
7955                                 mc->mc_ki[ptop] >= NUMKEYS(mc->mc_pg[ptop])) {
7956                                 for (i=0; i<=ptop; i++) {
7957                                         mc->mc_pg[i] = mn.mc_pg[i];
7958                                         mc->mc_ki[i] = mn.mc_ki[i];
7959                                 }
7960                         }
7961                 }
7962         }
7963
7964         {
7965                 /* Adjust other cursors pointing to mp */
7966                 MDB_cursor *m2, *m3;
7967                 MDB_dbi dbi = mc->mc_dbi;
7968                 int fixup = NUMKEYS(mp);
7969
7970                 for (m2 = mc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7971                         if (mc->mc_flags & C_SUB)
7972                                 m3 = &m2->mc_xcursor->mx_cursor;
7973                         else
7974                                 m3 = m2;
7975                         if (m3 == mc)
7976                                 continue;
7977                         if (!(m2->mc_flags & m3->mc_flags & C_INITIALIZED))
7978                                 continue;
7979                         if (m3->mc_flags & C_SPLITTING)
7980                                 continue;
7981                         if (new_root) {
7982                                 int k;
7983                                 /* root split */
7984                                 for (k=m3->mc_top; k>=0; k--) {
7985                                         m3->mc_ki[k+1] = m3->mc_ki[k];
7986                                         m3->mc_pg[k+1] = m3->mc_pg[k];
7987                                 }
7988                                 if (m3->mc_ki[0] >= split_indx) {
7989                                         m3->mc_ki[0] = 1;
7990                                 } else {
7991                                         m3->mc_ki[0] = 0;
7992                                 }
7993                                 m3->mc_pg[0] = mc->mc_pg[0];
7994                                 m3->mc_snum++;
7995                                 m3->mc_top++;
7996                         }
7997                         if (m3->mc_top >= mc->mc_top && m3->mc_pg[mc->mc_top] == mp) {
7998                                 if (m3->mc_ki[mc->mc_top] >= newindx && !(nflags & MDB_SPLIT_REPLACE))
7999                                         m3->mc_ki[mc->mc_top]++;
8000                                 if (m3->mc_ki[mc->mc_top] >= fixup) {
8001                                         m3->mc_pg[mc->mc_top] = rp;
8002                                         m3->mc_ki[mc->mc_top] -= fixup;
8003                                         m3->mc_ki[ptop] = mn.mc_ki[ptop];
8004                                 }
8005                         } else if (!did_split && m3->mc_top >= ptop && m3->mc_pg[ptop] == mc->mc_pg[ptop] &&
8006                                 m3->mc_ki[ptop] >= mc->mc_ki[ptop]) {
8007                                 m3->mc_ki[ptop]++;
8008                         }
8009                 }
8010         }
8011         DPRINTF(("mp left: %d, rp left: %d", SIZELEFT(mp), SIZELEFT(rp)));
8012
8013 done:
8014         if (copy)                                       /* tmp page */
8015                 mdb_page_free(env, copy);
8016         if (rc)
8017                 mc->mc_txn->mt_flags |= MDB_TXN_ERROR;
8018         return rc;
8019 }
8020
8021 int
8022 mdb_put(MDB_txn *txn, MDB_dbi dbi,
8023     MDB_val *key, MDB_val *data, unsigned int flags)
8024 {
8025         MDB_cursor mc;
8026         MDB_xcursor mx;
8027
8028         if (!key || !data || dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8029                 return EINVAL;
8030
8031         if ((flags & (MDB_NOOVERWRITE|MDB_NODUPDATA|MDB_RESERVE|MDB_APPEND|MDB_APPENDDUP)) != flags)
8032                 return EINVAL;
8033
8034         mdb_cursor_init(&mc, txn, dbi, &mx);
8035         return mdb_cursor_put(&mc, key, data, flags);
8036 }
8037
8038 int
8039 mdb_env_set_flags(MDB_env *env, unsigned int flag, int onoff)
8040 {
8041         if ((flag & CHANGEABLE) != flag)
8042                 return EINVAL;
8043         if (onoff)
8044                 env->me_flags |= flag;
8045         else
8046                 env->me_flags &= ~flag;
8047         return MDB_SUCCESS;
8048 }
8049
8050 int
8051 mdb_env_get_flags(MDB_env *env, unsigned int *arg)
8052 {
8053         if (!env || !arg)
8054                 return EINVAL;
8055
8056         *arg = env->me_flags;
8057         return MDB_SUCCESS;
8058 }
8059
8060 int
8061 mdb_env_set_userctx(MDB_env *env, void *ctx)
8062 {
8063         if (!env)
8064                 return EINVAL;
8065         env->me_userctx = ctx;
8066         return MDB_SUCCESS;
8067 }
8068
8069 void *
8070 mdb_env_get_userctx(MDB_env *env)
8071 {
8072         return env ? env->me_userctx : NULL;
8073 }
8074
8075 int
8076 mdb_env_set_assert(MDB_env *env, MDB_assert_func *func)
8077 {
8078         if (!env)
8079                 return EINVAL;
8080 #ifndef NDEBUG
8081         env->me_assert_func = func;
8082 #endif
8083         return MDB_SUCCESS;
8084 }
8085
8086 int
8087 mdb_env_get_path(MDB_env *env, const char **arg)
8088 {
8089         if (!env || !arg)
8090                 return EINVAL;
8091
8092         *arg = env->me_path;
8093         return MDB_SUCCESS;
8094 }
8095
8096 int
8097 mdb_env_get_fd(MDB_env *env, mdb_filehandle_t *arg)
8098 {
8099         if (!env || !arg)
8100                 return EINVAL;
8101
8102         *arg = env->me_fd;
8103         return MDB_SUCCESS;
8104 }
8105
8106 /** Common code for #mdb_stat() and #mdb_env_stat().
8107  * @param[in] env the environment to operate in.
8108  * @param[in] db the #MDB_db record containing the stats to return.
8109  * @param[out] arg the address of an #MDB_stat structure to receive the stats.
8110  * @return 0, this function always succeeds.
8111  */
8112 static int
8113 mdb_stat0(MDB_env *env, MDB_db *db, MDB_stat *arg)
8114 {
8115         arg->ms_psize = env->me_psize;
8116         arg->ms_depth = db->md_depth;
8117         arg->ms_branch_pages = db->md_branch_pages;
8118         arg->ms_leaf_pages = db->md_leaf_pages;
8119         arg->ms_overflow_pages = db->md_overflow_pages;
8120         arg->ms_entries = db->md_entries;
8121
8122         return MDB_SUCCESS;
8123 }
8124 int
8125 mdb_env_stat(MDB_env *env, MDB_stat *arg)
8126 {
8127         int toggle;
8128
8129         if (env == NULL || arg == NULL)
8130                 return EINVAL;
8131
8132         toggle = mdb_env_pick_meta(env);
8133
8134         return mdb_stat0(env, &env->me_metas[toggle]->mm_dbs[MAIN_DBI], arg);
8135 }
8136
8137 int
8138 mdb_env_info(MDB_env *env, MDB_envinfo *arg)
8139 {
8140         int toggle;
8141
8142         if (env == NULL || arg == NULL)
8143                 return EINVAL;
8144
8145         toggle = mdb_env_pick_meta(env);
8146         arg->me_mapaddr = (env->me_flags & MDB_FIXEDMAP) ? env->me_map : 0;
8147         arg->me_mapsize = env->me_mapsize;
8148         arg->me_maxreaders = env->me_maxreaders;
8149
8150         /* me_numreaders may be zero if this process never used any readers. Use
8151          * the shared numreader count if it exists.
8152          */
8153         arg->me_numreaders = env->me_txns ? env->me_txns->mti_numreaders : env->me_numreaders;
8154
8155         arg->me_last_pgno = env->me_metas[toggle]->mm_last_pg;
8156         arg->me_last_txnid = env->me_metas[toggle]->mm_txnid;
8157         return MDB_SUCCESS;
8158 }
8159
8160 /** Set the default comparison functions for a database.
8161  * Called immediately after a database is opened to set the defaults.
8162  * The user can then override them with #mdb_set_compare() or
8163  * #mdb_set_dupsort().
8164  * @param[in] txn A transaction handle returned by #mdb_txn_begin()
8165  * @param[in] dbi A database handle returned by #mdb_dbi_open()
8166  */
8167 static void
8168 mdb_default_cmp(MDB_txn *txn, MDB_dbi dbi)
8169 {
8170         uint16_t f = txn->mt_dbs[dbi].md_flags;
8171
8172         txn->mt_dbxs[dbi].md_cmp =
8173                 (f & MDB_REVERSEKEY) ? mdb_cmp_memnr :
8174                 (f & MDB_INTEGERKEY) ? mdb_cmp_cint  : mdb_cmp_memn;
8175
8176         txn->mt_dbxs[dbi].md_dcmp =
8177                 !(f & MDB_DUPSORT) ? 0 :
8178                 ((f & MDB_INTEGERDUP)
8179                  ? ((f & MDB_DUPFIXED)   ? mdb_cmp_int   : mdb_cmp_cint)
8180                  : ((f & MDB_REVERSEDUP) ? mdb_cmp_memnr : mdb_cmp_memn));
8181 }
8182
8183 int mdb_dbi_open(MDB_txn *txn, const char *name, unsigned int flags, MDB_dbi *dbi)
8184 {
8185         MDB_val key, data;
8186         MDB_dbi i;
8187         MDB_cursor mc;
8188         int rc, dbflag, exact;
8189         unsigned int unused = 0;
8190         size_t len;
8191
8192         if (txn->mt_dbxs[FREE_DBI].md_cmp == NULL) {
8193                 mdb_default_cmp(txn, FREE_DBI);
8194         }
8195
8196         if ((flags & VALID_FLAGS) != flags)
8197                 return EINVAL;
8198         if (txn->mt_flags & MDB_TXN_ERROR)
8199                 return MDB_BAD_TXN;
8200
8201         /* main DB? */
8202         if (!name) {
8203                 *dbi = MAIN_DBI;
8204                 if (flags & PERSISTENT_FLAGS) {
8205                         uint16_t f2 = flags & PERSISTENT_FLAGS;
8206                         /* make sure flag changes get committed */
8207                         if ((txn->mt_dbs[MAIN_DBI].md_flags | f2) != txn->mt_dbs[MAIN_DBI].md_flags) {
8208                                 txn->mt_dbs[MAIN_DBI].md_flags |= f2;
8209                                 txn->mt_flags |= MDB_TXN_DIRTY;
8210                         }
8211                 }
8212                 mdb_default_cmp(txn, MAIN_DBI);
8213                 return MDB_SUCCESS;
8214         }
8215
8216         if (txn->mt_dbxs[MAIN_DBI].md_cmp == NULL) {
8217                 mdb_default_cmp(txn, MAIN_DBI);
8218         }
8219
8220         /* Is the DB already open? */
8221         len = strlen(name);
8222         for (i=2; i<txn->mt_numdbs; i++) {
8223                 if (!txn->mt_dbxs[i].md_name.mv_size) {
8224                         /* Remember this free slot */
8225                         if (!unused) unused = i;
8226                         continue;
8227                 }
8228                 if (len == txn->mt_dbxs[i].md_name.mv_size &&
8229                         !strncmp(name, txn->mt_dbxs[i].md_name.mv_data, len)) {
8230                         *dbi = i;
8231                         return MDB_SUCCESS;
8232                 }
8233         }
8234
8235         /* If no free slot and max hit, fail */
8236         if (!unused && txn->mt_numdbs >= txn->mt_env->me_maxdbs)
8237                 return MDB_DBS_FULL;
8238
8239         /* Cannot mix named databases with some mainDB flags */
8240         if (txn->mt_dbs[MAIN_DBI].md_flags & (MDB_DUPSORT|MDB_INTEGERKEY))
8241                 return (flags & MDB_CREATE) ? MDB_INCOMPATIBLE : MDB_NOTFOUND;
8242
8243         /* Find the DB info */
8244         dbflag = DB_NEW|DB_VALID;
8245         exact = 0;
8246         key.mv_size = len;
8247         key.mv_data = (void *)name;
8248         mdb_cursor_init(&mc, txn, MAIN_DBI, NULL);
8249         rc = mdb_cursor_set(&mc, &key, &data, MDB_SET, &exact);
8250         if (rc == MDB_SUCCESS) {
8251                 /* make sure this is actually a DB */
8252                 MDB_node *node = NODEPTR(mc.mc_pg[mc.mc_top], mc.mc_ki[mc.mc_top]);
8253                 if (!(node->mn_flags & F_SUBDATA))
8254                         return MDB_INCOMPATIBLE;
8255         } else if (rc == MDB_NOTFOUND && (flags & MDB_CREATE)) {
8256                 /* Create if requested */
8257                 MDB_db dummy;
8258                 data.mv_size = sizeof(MDB_db);
8259                 data.mv_data = &dummy;
8260                 memset(&dummy, 0, sizeof(dummy));
8261                 dummy.md_root = P_INVALID;
8262                 dummy.md_flags = flags & PERSISTENT_FLAGS;
8263                 rc = mdb_cursor_put(&mc, &key, &data, F_SUBDATA);
8264                 dbflag |= DB_DIRTY;
8265         }
8266
8267         /* OK, got info, add to table */
8268         if (rc == MDB_SUCCESS) {
8269                 unsigned int slot = unused ? unused : txn->mt_numdbs;
8270                 txn->mt_dbxs[slot].md_name.mv_data = strdup(name);
8271                 txn->mt_dbxs[slot].md_name.mv_size = len;
8272                 txn->mt_dbxs[slot].md_rel = NULL;
8273                 txn->mt_dbflags[slot] = dbflag;
8274                 memcpy(&txn->mt_dbs[slot], data.mv_data, sizeof(MDB_db));
8275                 *dbi = slot;
8276                 mdb_default_cmp(txn, slot);
8277                 if (!unused) {
8278                         txn->mt_numdbs++;
8279                 }
8280         }
8281
8282         return rc;
8283 }
8284
8285 int mdb_stat(MDB_txn *txn, MDB_dbi dbi, MDB_stat *arg)
8286 {
8287         if (!arg || !TXN_DBI_EXIST(txn, dbi))
8288                 return EINVAL;
8289
8290         if (txn->mt_flags & MDB_TXN_ERROR)
8291                 return MDB_BAD_TXN;
8292
8293         if (txn->mt_dbflags[dbi] & DB_STALE) {
8294                 MDB_cursor mc;
8295                 MDB_xcursor mx;
8296                 /* Stale, must read the DB's root. cursor_init does it for us. */
8297                 mdb_cursor_init(&mc, txn, dbi, &mx);
8298         }
8299         return mdb_stat0(txn->mt_env, &txn->mt_dbs[dbi], arg);
8300 }
8301
8302 void mdb_dbi_close(MDB_env *env, MDB_dbi dbi)
8303 {
8304         char *ptr;
8305         if (dbi <= MAIN_DBI || dbi >= env->me_maxdbs)
8306                 return;
8307         ptr = env->me_dbxs[dbi].md_name.mv_data;
8308         env->me_dbxs[dbi].md_name.mv_data = NULL;
8309         env->me_dbxs[dbi].md_name.mv_size = 0;
8310         env->me_dbflags[dbi] = 0;
8311         free(ptr);
8312 }
8313
8314 int mdb_dbi_flags(MDB_txn *txn, MDB_dbi dbi, unsigned int *flags)
8315 {
8316         /* We could return the flags for the FREE_DBI too but what's the point? */
8317         if (dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8318                 return EINVAL;
8319         *flags = txn->mt_dbs[dbi].md_flags & PERSISTENT_FLAGS;
8320         return MDB_SUCCESS;
8321 }
8322
8323 /** Add all the DB's pages to the free list.
8324  * @param[in] mc Cursor on the DB to free.
8325  * @param[in] subs non-Zero to check for sub-DBs in this DB.
8326  * @return 0 on success, non-zero on failure.
8327  */
8328 static int
8329 mdb_drop0(MDB_cursor *mc, int subs)
8330 {
8331         int rc;
8332
8333         rc = mdb_page_search(mc, NULL, MDB_PS_FIRST);
8334         if (rc == MDB_SUCCESS) {
8335                 MDB_txn *txn = mc->mc_txn;
8336                 MDB_node *ni;
8337                 MDB_cursor mx;
8338                 unsigned int i;
8339
8340                 /* LEAF2 pages have no nodes, cannot have sub-DBs */
8341                 if (IS_LEAF2(mc->mc_pg[mc->mc_top]))
8342                         mdb_cursor_pop(mc);
8343
8344                 mdb_cursor_copy(mc, &mx);
8345                 while (mc->mc_snum > 0) {
8346                         MDB_page *mp = mc->mc_pg[mc->mc_top];
8347                         unsigned n = NUMKEYS(mp);
8348                         if (IS_LEAF(mp)) {
8349                                 for (i=0; i<n; i++) {
8350                                         ni = NODEPTR(mp, i);
8351                                         if (ni->mn_flags & F_BIGDATA) {
8352                                                 MDB_page *omp;
8353                                                 pgno_t pg;
8354                                                 memcpy(&pg, NODEDATA(ni), sizeof(pg));
8355                                                 rc = mdb_page_get(txn, pg, &omp, NULL);
8356                                                 if (rc != 0)
8357                                                         goto done;
8358                                                 mdb_cassert(mc, IS_OVERFLOW(omp));
8359                                                 rc = mdb_midl_append_range(&txn->mt_free_pgs,
8360                                                         pg, omp->mp_pages);
8361                                                 if (rc)
8362                                                         goto done;
8363                                         } else if (subs && (ni->mn_flags & F_SUBDATA)) {
8364                                                 mdb_xcursor_init1(mc, ni);
8365                                                 rc = mdb_drop0(&mc->mc_xcursor->mx_cursor, 0);
8366                                                 if (rc)
8367                                                         goto done;
8368                                         }
8369                                 }
8370                         } else {
8371                                 if ((rc = mdb_midl_need(&txn->mt_free_pgs, n)) != 0)
8372                                         goto done;
8373                                 for (i=0; i<n; i++) {
8374                                         pgno_t pg;
8375                                         ni = NODEPTR(mp, i);
8376                                         pg = NODEPGNO(ni);
8377                                         /* free it */
8378                                         mdb_midl_xappend(txn->mt_free_pgs, pg);
8379                                 }
8380                         }
8381                         if (!mc->mc_top)
8382                                 break;
8383                         mc->mc_ki[mc->mc_top] = i;
8384                         rc = mdb_cursor_sibling(mc, 1);
8385                         if (rc) {
8386                                 if (rc != MDB_NOTFOUND)
8387                                         goto done;
8388                                 /* no more siblings, go back to beginning
8389                                  * of previous level.
8390                                  */
8391                                 mdb_cursor_pop(mc);
8392                                 mc->mc_ki[0] = 0;
8393                                 for (i=1; i<mc->mc_snum; i++) {
8394                                         mc->mc_ki[i] = 0;
8395                                         mc->mc_pg[i] = mx.mc_pg[i];
8396                                 }
8397                         }
8398                 }
8399                 /* free it */
8400                 rc = mdb_midl_append(&txn->mt_free_pgs, mc->mc_db->md_root);
8401 done:
8402                 if (rc)
8403                         txn->mt_flags |= MDB_TXN_ERROR;
8404         } else if (rc == MDB_NOTFOUND) {
8405                 rc = MDB_SUCCESS;
8406         }
8407         return rc;
8408 }
8409
8410 int mdb_drop(MDB_txn *txn, MDB_dbi dbi, int del)
8411 {
8412         MDB_cursor *mc, *m2;
8413         int rc;
8414
8415         if ((unsigned)del > 1 || dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8416                 return EINVAL;
8417
8418         if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY))
8419                 return EACCES;
8420
8421         rc = mdb_cursor_open(txn, dbi, &mc);
8422         if (rc)
8423                 return rc;
8424
8425         rc = mdb_drop0(mc, mc->mc_db->md_flags & MDB_DUPSORT);
8426         /* Invalidate the dropped DB's cursors */
8427         for (m2 = txn->mt_cursors[dbi]; m2; m2 = m2->mc_next)
8428                 m2->mc_flags &= ~(C_INITIALIZED|C_EOF);
8429         if (rc)
8430                 goto leave;
8431
8432         /* Can't delete the main DB */
8433         if (del && dbi > MAIN_DBI) {
8434                 rc = mdb_del0(txn, MAIN_DBI, &mc->mc_dbx->md_name, NULL, 0);
8435                 if (!rc) {
8436                         txn->mt_dbflags[dbi] = DB_STALE;
8437                         mdb_dbi_close(txn->mt_env, dbi);
8438                 } else {
8439                         txn->mt_flags |= MDB_TXN_ERROR;
8440                 }
8441         } else {
8442                 /* reset the DB record, mark it dirty */
8443                 txn->mt_dbflags[dbi] |= DB_DIRTY;
8444                 txn->mt_dbs[dbi].md_depth = 0;
8445                 txn->mt_dbs[dbi].md_branch_pages = 0;
8446                 txn->mt_dbs[dbi].md_leaf_pages = 0;
8447                 txn->mt_dbs[dbi].md_overflow_pages = 0;
8448                 txn->mt_dbs[dbi].md_entries = 0;
8449                 txn->mt_dbs[dbi].md_root = P_INVALID;
8450
8451                 txn->mt_flags |= MDB_TXN_DIRTY;
8452         }
8453 leave:
8454         mdb_cursor_close(mc);
8455         return rc;
8456 }
8457
8458 int mdb_set_compare(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)
8459 {
8460         if (dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8461                 return EINVAL;
8462
8463         txn->mt_dbxs[dbi].md_cmp = cmp;
8464         return MDB_SUCCESS;
8465 }
8466
8467 int mdb_set_dupsort(MDB_txn *txn, MDB_dbi dbi, MDB_cmp_func *cmp)
8468 {
8469         if (dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8470                 return EINVAL;
8471
8472         txn->mt_dbxs[dbi].md_dcmp = cmp;
8473         return MDB_SUCCESS;
8474 }
8475
8476 int mdb_set_relfunc(MDB_txn *txn, MDB_dbi dbi, MDB_rel_func *rel)
8477 {
8478         if (dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8479                 return EINVAL;
8480
8481         txn->mt_dbxs[dbi].md_rel = rel;
8482         return MDB_SUCCESS;
8483 }
8484
8485 int mdb_set_relctx(MDB_txn *txn, MDB_dbi dbi, void *ctx)
8486 {
8487         if (dbi == FREE_DBI || !TXN_DBI_EXIST(txn, dbi))
8488                 return EINVAL;
8489
8490         txn->mt_dbxs[dbi].md_relctx = ctx;
8491         return MDB_SUCCESS;
8492 }
8493
8494 int mdb_env_get_maxkeysize(MDB_env *env)
8495 {
8496         return ENV_MAXKEY(env);
8497 }
8498
8499 int mdb_reader_list(MDB_env *env, MDB_msg_func *func, void *ctx)
8500 {
8501         unsigned int i, rdrs;
8502         MDB_reader *mr;
8503         char buf[64];
8504         int rc = 0, first = 1;
8505
8506         if (!env || !func)
8507                 return -1;
8508         if (!env->me_txns) {
8509                 return func("(no reader locks)\n", ctx);
8510         }
8511         rdrs = env->me_txns->mti_numreaders;
8512         mr = env->me_txns->mti_readers;
8513         for (i=0; i<rdrs; i++) {
8514                 if (mr[i].mr_pid) {
8515                         txnid_t txnid = mr[i].mr_txnid;
8516                         sprintf(buf, txnid == (txnid_t)-1 ?
8517                                 "%10d %"Z"x -\n" : "%10d %"Z"x %"Z"u\n",
8518                                 (int)mr[i].mr_pid, (size_t)mr[i].mr_tid, txnid);
8519                         if (first) {
8520                                 first = 0;
8521                                 rc = func("    pid     thread     txnid\n", ctx);
8522                                 if (rc < 0)
8523                                         break;
8524                         }
8525                         rc = func(buf, ctx);
8526                         if (rc < 0)
8527                                 break;
8528                 }
8529         }
8530         if (first) {
8531                 rc = func("(no active readers)\n", ctx);
8532         }
8533         return rc;
8534 }
8535
8536 /** Insert pid into list if not already present.
8537  * return -1 if already present.
8538  */
8539 static int mdb_pid_insert(MDB_PID_T *ids, MDB_PID_T pid)
8540 {
8541         /* binary search of pid in list */
8542         unsigned base = 0;
8543         unsigned cursor = 1;
8544         int val = 0;
8545         unsigned n = ids[0];
8546
8547         while( 0 < n ) {
8548                 unsigned pivot = n >> 1;
8549                 cursor = base + pivot + 1;
8550                 val = pid - ids[cursor];
8551
8552                 if( val < 0 ) {
8553                         n = pivot;
8554
8555                 } else if ( val > 0 ) {
8556                         base = cursor;
8557                         n -= pivot + 1;
8558
8559                 } else {
8560                         /* found, so it's a duplicate */
8561                         return -1;
8562                 }
8563         }
8564
8565         if( val > 0 ) {
8566                 ++cursor;
8567         }
8568         ids[0]++;
8569         for (n = ids[0]; n > cursor; n--)
8570                 ids[n] = ids[n-1];
8571         ids[n] = pid;
8572         return 0;
8573 }
8574
8575 int mdb_reader_check(MDB_env *env, int *dead)
8576 {
8577         unsigned int i, j, rdrs;
8578         MDB_reader *mr;
8579         MDB_PID_T *pids, pid;
8580         int count = 0;
8581
8582         if (!env)
8583                 return EINVAL;
8584         if (dead)
8585                 *dead = 0;
8586         if (!env->me_txns)
8587                 return MDB_SUCCESS;
8588         rdrs = env->me_txns->mti_numreaders;
8589         pids = malloc((rdrs+1) * sizeof(MDB_PID_T));
8590         if (!pids)
8591                 return ENOMEM;
8592         pids[0] = 0;
8593         mr = env->me_txns->mti_readers;
8594         for (i=0; i<rdrs; i++) {
8595                 if (mr[i].mr_pid && mr[i].mr_pid != env->me_pid) {
8596                         pid = mr[i].mr_pid;
8597                         if (mdb_pid_insert(pids, pid) == 0) {
8598                                 if (!mdb_reader_pid(env, Pidcheck, pid)) {
8599                                         LOCK_MUTEX_R(env);
8600                                         /* Recheck, a new process may have reused pid */
8601                                         if (!mdb_reader_pid(env, Pidcheck, pid)) {
8602                                                 for (j=i; j<rdrs; j++)
8603                                                         if (mr[j].mr_pid == pid) {
8604                                                                 DPRINTF(("clear stale reader pid %u txn %"Z"d",
8605                                                                         (unsigned) pid, mr[j].mr_txnid));
8606                                                                 mr[j].mr_pid = 0;
8607                                                                 count++;
8608                                                         }
8609                                         }
8610                                         UNLOCK_MUTEX_R(env);
8611                                 }
8612                         }
8613                 }
8614         }
8615         free(pids);
8616         if (dead)
8617                 *dead = count;
8618         return MDB_SUCCESS;
8619 }
8620 /** @} */