Commit 4e9e47d95325632c828f35ffff61f59884e0161d - lmdb

Merge tag 'upstream/0.9.14' Upstream version 0.9.14 Ondřej Surý 9 years ago

28 changed file(s) with 2998 addition(s) and 919 deletion(s). Raw diff Collapse all Expand all

-0

libraries/liblmdb/.gitignore less more

4	4	mdb_stat
5	5	*.[ao]
6	6	*.so
	7	*.exe
7	8	*[~#]
8	9	*.bak
9	10	*.orig
10	11	*.rej
	12	*.gcov
	13	*.gcda
	14	*.gcno
11	15	core
12	16	core.*
13	17	valgrind.*

+35

-0

libraries/liblmdb/CHANGES less more

0	0	LMDB 0.9 Change Log
	1
	2	LMDB 0.9.14 Release (2014/09/20)
	3	Fix to support 64K page size (ITS#7713)
	4	Fix to persist decreased as well as increased mapsizes (ITS#7789)
	5	Fix cursor bug when deleting last node of a DUPSORT key
	6	Fix mdb_env_info to return FIXEDMAP address
	7	Fix ambiguous error code from writing to closed DBI (ITS#7825)
	8	Fix mdb_copy copying past end of file (ITS#7886)
	9	Fix cursor bugs from page_merge/rebalance
	10	Fix to dirty fewer pages in deletes (mdb_page_loose())
	11	Fix mdb_dbi_open creating subDBs (ITS#7917)
	12	Fix mdb_cursor_get(_DUP) with single value (ITS#7913)
	13	Fix Windows compat issues in mtests (ITS#7879)
	14	Add compacting variant of mdb_copy
	15	Add BigEndian integer key compare code
	16	Add mdb_dump/mdb_load utilities
	17
	18	LMDB 0.9.13 Release (2014/06/18)
	19	Fix mdb_page_alloc unlimited overflow page search
	20	Documentation
	21	Re-fix MDB_CURRENT doc (ITS#7793)
	22	Fix MDB_GET_MULTIPLE/MDB_NEXT_MULTIPLE doc
	23
	24	LMDB 0.9.12 Release (2014/06/13)
	25	Fix MDB_GET_BOTH regression (ITS#7875,#7681)
	26	Fix MDB_MULTIPLE writing multiple keys (ITS#7834)
	27	Fix mdb_rebalance (ITS#7829)
	28	Fix mdb_page_split (ITS#7815)
	29	Fix md_entries count (ITS#7861,#7828,#7793)
	30	Fix MDB_CURRENT (ITS#7793)
	31	Fix possible crash on Windows DLL detach
	32	Misc code cleanup
	33	Documentation
	34	mdb_cursor_put: cursor moves on error (ITS#7771)
	35
1	36
2	37	LMDB 0.9.11 Release (2014/01/15)
3	38	Add mdb_env_set_assert() (ITS#7775)

-1

libraries/liblmdb/COPYRIGHT less more

0		Copyright 2011-2013 Howard Chu, Symas Corp.
	0	Copyright 2011-2014 Howard Chu, Symas Corp.
1	1	All rights reserved.
2	2
3	3	Redistribution and use in source and binary forms, with or without

-2

libraries/liblmdb/Doxyfile less more

24	24	# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
25	25	# by quotes) that should identify the project.
26	26
27		PROJECT_NAME = MDB
	27	PROJECT_NAME = LMDB
28	28
29	29	# The PROJECT_NUMBER tag can be used to enter a project or revision number.
30	30	# This could be handy for archiving the generated documentation or

1403	1403	# If a tag file is not located in the directory in which doxygen
1404	1404	# is run, you must also specify the path to the tagfile here.
1405	1405
1406		TAGFILES =
	1406	TAGFILES = tooltag=./man1
1407	1407
1408	1408	# When a file name is specified after GENERATE_TAGFILE, doxygen will create
1409	1409	# a tag file that is based on the input files it reads.

+24

-3

libraries/liblmdb/Makefile less more

16	16	# read mdb.c before changing any of them.
17	17	#
18	18	CC = gcc
19		W = -W -Wall -Wno-unused-parameter -Wbad-function-cast
	19	W = -W -Wall -Wno-unused-parameter -Wbad-function-cast -Wuninitialized
20	20	THREADS = -pthread
21	21	OPT = -O2 -g
22	22	CFLAGS = $(THREADS) $(OPT) $(W) $(XCFLAGS)

28	28
29	29	IHDRS = lmdb.h
30	30	ILIBS = liblmdb.a liblmdb.so
31		IPROGS = mdb_stat mdb_copy
32		IDOCS = mdb_stat.1 mdb_copy.1
	31	IPROGS = mdb_stat mdb_copy mdb_dump mdb_load
	32	IDOCS = mdb_stat.1 mdb_copy.1 mdb_dump.1 mdb_load.1
33	33	PROGS = $(IPROGS) mtest mtest2 mtest3 mtest4 mtest5
34	34	all: $(ILIBS) $(PROGS)
35	35

55	55
56	56	mdb_stat: mdb_stat.o liblmdb.a
57	57	mdb_copy: mdb_copy.o liblmdb.a
	58	mdb_dump: mdb_dump.o liblmdb.a
	59	mdb_load: mdb_load.o liblmdb.a
58	60	mtest: mtest.o liblmdb.a
59	61	mtest2: mtest2.o liblmdb.a
60	62	mtest3: mtest3.o liblmdb.a

73	75
74	76	%.o: %.c lmdb.h
75	77	$(CC) $(CFLAGS) $(CPPFLAGS) -c $<
	78
	79	COV_FLAGS=-fprofile-arcs -ftest-coverage
	80	COV_OBJS=xmdb.o xmidl.o
	81
	82	coverage: xmtest
	83	for i in mtest.c [0-9].c; do j=`basename \$$i .c`; $(MAKE) $$j.o; \
	84	gcc -o x$$j $$j.o $(COV_OBJS) -pthread $(COV_FLAGS); \
	85	rm -rf testdb; mkdir testdb; ./x$$j; done
	86	gcov xmdb.c
	87	gcov xmidl.c
	88
	89	xmtest: mtest.o xmdb.o xmidl.o
	90	gcc -o xmtest mtest.o xmdb.o xmidl.o -pthread $(COV_FLAGS)
	91
	92	xmdb.o: mdb.c lmdb.h midl.h
	93	$(CC) $(CFLAGS) -fPIC $(CPPFLAGS) -O0 $(COV_FLAGS) -c mdb.c -o $@
	94
	95	xmidl.o: midl.c midl.h
	96	$(CC) $(CFLAGS) -fPIC $(CPPFLAGS) -O0 $(COV_FLAGS) -c midl.c -o $@

+135

-47

libraries/liblmdb/lmdb.h less more

0	0	/** @file lmdb.h
1	1	* @brief Lightning memory-mapped database library
2	2	*
3		* @mainpage Lightning Memory-Mapped Database Manager (MDB)
	3	* @mainpage Lightning Memory-Mapped Database Manager (LMDB)
4	4	*
5	5	* @section intro_sec Introduction
6		* MDB is a Btree-based database management library modeled loosely on the
	6	* LMDB is a Btree-based database management library modeled loosely on the
7	7	* BerkeleyDB API, but much simplified. The entire database is exposed
8	8	* in a memory map, and all data fetches return data directly
9	9	* from the mapped memory, so no malloc's or memcpy's occur during

25	25	* readers, and readers don't block writers.
26	26	*
27	27	* Unlike other well-known database mechanisms which use either write-ahead
28		* transaction logs or append-only data writes, MDB requires no maintenance
	28	* transaction logs or append-only data writes, LMDB requires no maintenance
29	29	* during operation. Both write-ahead loggers and append-only databases
30	30	* require periodic checkpointing and/or compaction of their log or database
31		* files otherwise they grow without bound. MDB tracks free pages within
	31	* files otherwise they grow without bound. LMDB tracks free pages within
32	32	* the database and re-uses them for new write operations, so the database
33	33	* size does not grow without bound in normal use.
34	34	*

48	48	* stale locks can block further operation.
49	49	*
50	50	* Fix: Check for stale readers periodically, using the
51		* #mdb_reader_check function or the mdb_stat tool. Or just
	51	* #mdb_reader_check function or the \ref mdb_stat_1 "mdb_stat" tool. Or just
52	52	* make all programs using the database close it; the lockfile
53	53	* is always reset on first open of the environment.
54	54	*

85	85	*
86	86	* - Use an MDB_env* in the process which opened it, without fork()ing.
87	87	*
88		* - Do not have open an MDB database twice in the same process at
	88	* - Do not have open an LMDB database twice in the same process at
89	89	* the same time. Not even from a plain open() call - close()ing it
90	90	* breaks flock() advisory locking.
91	91	*

108	108	* - If you do that anyway, do a periodic check for stale readers. Or
109	109	* close the environment once in a while, so the lockfile can get reset.
110	110	*
111		* - Do not use MDB databases on remote filesystems, even between
	111	* - Do not use LMDB databases on remote filesystems, even between
112	112	* processes on the same host. This breaks flock() on some OSes,
113	113	* possibly memory map sync, and certainly sync between programs
114	114	* on different hosts.

118	118	*
119	119	* @author Howard Chu, Symas Corporation.
120	120	*
121		* @copyright Copyright 2011-2013 Howard Chu, Symas Corp. All rights reserved.
	121	* @copyright Copyright 2011-2014 Howard Chu, Symas Corp. All rights reserved.
122	122	*
123	123	* Redistribution and use in source and binary forms, with or without
124	124	* modification, are permitted only as authorized by the OpenLDAP

171	171	typedef int mdb_filehandle_t;
172	172	#endif
173	173
174		/** @defgroup mdb MDB API
	174	/** @defgroup mdb LMDB API
175	175	* @{
176	176	* @brief OpenLDAP Lightning Memory-Mapped Database Manager
177	177	*/

183	183	/** Library minor version */
184	184	#define MDB_VERSION_MINOR 9
185	185	/** Library patch version */
186		#define MDB_VERSION_PATCH 11
	186	#define MDB_VERSION_PATCH 14
187	187
188	188	/** Combine args a,b,c into a single integer for easy version comparisons */
189	189	#define MDB_VERINT(a,b,c) (((a) << 24) \| ((b) << 16) \| (c))

193	193	MDB_VERINT(MDB_VERSION_MAJOR,MDB_VERSION_MINOR,MDB_VERSION_PATCH)
194	194
195	195	/** The release date of this library version */
196		#define MDB_VERSION_DATE "January 15, 2014"
	196	#define MDB_VERSION_DATE "September 20, 2014"
197	197
198	198	/** A stringifier for the version info */
199		#define MDB_VERSTR(a,b,c,d) "MDB " #a "." #b "." #c ": (" d ")"
	199	#define MDB_VERSTR(a,b,c,d) "LMDB " #a "." #b "." #c ": (" d ")"
200	200
201	201	/** A helper for the stringifier macro */
202	202	#define MDB_VERFOO(a,b,c,d) MDB_VERSTR(a,b,c,d)

332	332	#define MDB_MULTIPLE 0x80000
333	333	/* @} */
334	334
	335	/** @defgroup mdb_copy Copy Flags
	336	* @{
	337	*/
	338	/** Compacting copy: Omit free space from copy, and renumber all
	339	* pages sequentially.
	340	*/
	341	#define MDB_CP_COMPACT 0x01
	342	/* @} */
	343
335	344	/** @brief Cursor Get operations.
336	345	*
337	346	* This is the set of all operations for retrieving data

344	353	MDB_GET_BOTH, /*< Position at key/data pair. Only for #MDB_DUPSORT /
345	354	MDB_GET_BOTH_RANGE, /*< position at key, nearest data. Only for #MDB_DUPSORT /
346	355	MDB_GET_CURRENT, /*< Return key/data at current cursor position /
347		MDB_GET_MULTIPLE, /**< Return all the duplicate data items at the current
348		cursor position. Only for #MDB_DUPFIXED */
	356	MDB_GET_MULTIPLE, /**< Return key and up to a page of duplicate data items
	357	from current cursor position. Move cursor to prepare
	358	for #MDB_NEXT_MULTIPLE. Only for #MDB_DUPFIXED */
349	359	MDB_LAST, /*< Position at last key/data item /
350	360	MDB_LAST_DUP, /**< Position at last data item of current key.
351	361	Only for #MDB_DUPSORT */
352	362	MDB_NEXT, /*< Position at next data item /
353	363	MDB_NEXT_DUP, /**< Position at next data item of current key.
354	364	Only for #MDB_DUPSORT */
355		MDB_NEXT_MULTIPLE, /**< Return all duplicate data items at the next
356		cursor position. Only for #MDB_DUPFIXED */
	365	MDB_NEXT_MULTIPLE, /**< Return key and up to a page of duplicate data items
	366	from next cursor position. Move cursor to prepare
	367	for #MDB_NEXT_MULTIPLE. Only for #MDB_DUPFIXED */
357	368	MDB_NEXT_NODUP, /*< Position at first data item of next key /
358	369	MDB_PREV, /*< Position at previous data item /
359	370	MDB_PREV_DUP, /**< Position at previous data item of current key.

383	394	#define MDB_PANIC (-30795)
384	395	/** Environment version mismatch */
385	396	#define MDB_VERSION_MISMATCH (-30794)
386		/** File is not a valid MDB file */
	397	/** File is not a valid LMDB file */
387	398	#define MDB_INVALID (-30793)
388	399	/** Environment mapsize reached */
389	400	#define MDB_MAP_FULL (-30792)

407	418	#define MDB_BAD_RSLOT (-30783)
408	419	/** Transaction cannot recover - it must be aborted */
409	420	#define MDB_BAD_TXN (-30782)
410		/** Too big key/data, key is empty, or wrong DUPFIXED size */
	421	/** Unsupported size of key/DB name/data, or wrong DUPFIXED size */
411	422	#define MDB_BAD_VALSIZE (-30781)
412		#define MDB_LAST_ERRCODE MDB_BAD_VALSIZE
	423	/** The specified DBI was changed unexpectedly */
	424	#define MDB_BAD_DBI (-30780)
	425	/** The last defined error code */
	426	#define MDB_LAST_ERRCODE MDB_BAD_DBI
413	427	/** @} */
414	428
415	429	/** @brief Statistics for a database in the environment */

433	447	unsigned int me_numreaders; /*< max reader slots used in the environment /
434	448	} MDB_envinfo;
435	449
436		/** @brief Return the mdb library version information.
	450	/** @brief Return the LMDB library version information.
437	451	*
438	452	* @param[out] major if non-NULL, the library major version number is copied here
439	453	* @param[out] minor if non-NULL, the library minor version number is copied here

447	461	* This function is a superset of the ANSI C X3.159-1989 (ANSI C) strerror(3)
448	462	* function. If the error code is greater than or equal to 0, then the string
449	463	* returned by the system function strerror(3) is returned. If the error code
450		* is less than 0, an error string corresponding to the MDB library error is
451		* returned. See @ref errors for a list of MDB-specific error codes.
	464	* is less than 0, an error string corresponding to the LMDB library error is
	465	* returned. See @ref errors for a list of LMDB-specific error codes.
452	466	* @param[in] err The error code
453	467	* @retval "error message" The description of the error
454	468	*/
455	469	char *mdb_strerror(int err);
456	470
457		/** @brief Create an MDB environment handle.
	471	/** @brief Create an LMDB environment handle.
458	472	*
459	473	* This function allocates memory for a #MDB_env structure. To release
460	474	* the allocated memory and discard the handle, call #mdb_env_close().

487	501	* how the operating system has allocated memory to shared libraries and other uses.
488	502	* The feature is highly experimental.
489	503	* <li>#MDB_NOSUBDIR
490		* By default, MDB creates its environment in a directory whose
	504	* By default, LMDB creates its environment in a directory whose
491	505	* pathname is given in \b path, and creates its data and lock files
492	506	* under that directory. With this option, \b path is used as-is for
493	507	* the database main data file. The database lock file is the \b path
494	508	* with "-lock" appended.
495	509	* <li>#MDB_RDONLY
496	510	* Open the environment in read-only mode. No write operations will be
497		* allowed. MDB will still modify the lock file - except on read-only
498		* filesystems, where MDB does not use locks.
	511	* allowed. LMDB will still modify the lock file - except on read-only
	512	* filesystems, where LMDB does not use locks.
499	513	* <li>#MDB_WRITEMAP
500	514	* Use a writeable memory map unless MDB_RDONLY is set. This is faster
501	515	* and uses fewer mallocs, but loses protection from application bugs

539	553	* the user synchronizes its use. Applications that multiplex many
540	554	* user threads over individual OS threads need this option. Such an
541	555	* application must also serialize the write transactions in an OS
542		* thread, since MDB's write locking is unaware of the user threads.
	556	* thread, since LMDB's write locking is unaware of the user threads.
543	557	* <li>#MDB_NOLOCK
544	558	* Don't do any locking. If concurrent access is anticipated, the
545	559	* caller must manage all concurrency itself. For proper operation

578	592	* @return A non-zero error value on failure and 0 on success. Some possible
579	593	* errors are:
580	594	* <ul>
581		* <li>#MDB_VERSION_MISMATCH - the version of the MDB library doesn't match the
	595	* <li>#MDB_VERSION_MISMATCH - the version of the LMDB library doesn't match the
582	596	* version that created the database environment.
583	597	* <li>#MDB_INVALID - the environment file headers are corrupted.
584	598	* <li>ENOENT - the directory specified by the path parameter doesn't exist.

588	602	*/
589	603	int mdb_env_open(MDB_env env, const char path, unsigned int flags, mdb_mode_t mode);
590	604
591		/** @brief Copy an MDB environment to the specified path.
	605	/** @brief Copy an LMDB environment to the specified path.
592	606	*
593	607	* This function may be used to make a backup of an existing environment.
594	608	* No lockfile is created, since it gets recreated at need.

604	618	*/
605	619	int mdb_env_copy(MDB_env env, const char path);
606	620
607		/** @brief Copy an MDB environment to the specified file descriptor.
	621	/** @brief Copy an LMDB environment to the specified file descriptor.
608	622	*
609	623	* This function may be used to make a backup of an existing environment.
610	624	* No lockfile is created, since it gets recreated at need.

619	633	*/
620	634	int mdb_env_copyfd(MDB_env *env, mdb_filehandle_t fd);
621	635
622		/** @brief Return statistics about the MDB environment.
	636	/** @brief Copy an LMDB environment to the specified path, with options.
	637	*
	638	* This function may be used to make a backup of an existing environment.
	639	* No lockfile is created, since it gets recreated at need.
	640	* @note This call can trigger significant file size growth if run in
	641	* parallel with write transactions, because it employs a read-only
	642	* transaction. See long-lived transactions under @ref caveats_sec.
	643	* @param[in] env An environment handle returned by #mdb_env_create(). It
	644	* must have already been opened successfully.
	645	* @param[in] path The directory in which the copy will reside. This
	646	* directory must already exist and be writable but must otherwise be
	647	* empty.
	648	* @param[in] flags Special options for this operation. This parameter
	649	* must be set to 0 or by bitwise OR'ing together one or more of the
	650	* values described here.
	651	* <ul>
	652	* <li>#MDB_CP_COMPACT - Perform compaction while copying: omit free
	653	* pages and sequentially renumber all pages in output. This option
	654	* consumes more CPU and runs more slowly than the default.
	655	* </ul>
	656	* @return A non-zero error value on failure and 0 on success.
	657	*/
	658	int mdb_env_copy2(MDB_env env, const char path, unsigned int flags);
	659
	660	/** @brief Copy an LMDB environment to the specified file descriptor,
	661	* with options.
	662	*
	663	* This function may be used to make a backup of an existing environment.
	664	* No lockfile is created, since it gets recreated at need. See
	665	* #mdb_env_copy2() for further details.
	666	* @note This call can trigger significant file size growth if run in
	667	* parallel with write transactions, because it employs a read-only
	668	* transaction. See long-lived transactions under @ref caveats_sec.
	669	* @param[in] env An environment handle returned by #mdb_env_create(). It
	670	* must have already been opened successfully.
	671	* @param[in] fd The filedescriptor to write the copy to. It must
	672	* have already been opened for Write access.
	673	* @param[in] flags Special options for this operation.
	674	* See #mdb_env_copy2() for options.
	675	* @return A non-zero error value on failure and 0 on success.
	676	*/
	677	int mdb_env_copyfd2(MDB_env *env, mdb_filehandle_t fd, unsigned int flags);
	678
	679	/** @brief Return statistics about the LMDB environment.
623	680	*
624	681	* @param[in] env An environment handle returned by #mdb_env_create()
625	682	* @param[out] stat The address of an #MDB_stat structure

627	684	*/
628	685	int mdb_env_stat(MDB_env env, MDB_stat stat);
629	686
630		/** @brief Return information about the MDB environment.
	687	/** @brief Return information about the LMDB environment.
631	688	*
632	689	* @param[in] env An environment handle returned by #mdb_env_create()
633	690	* @param[out] stat The address of an #MDB_envinfo structure

638	695	/** @brief Flush the data buffers to disk.
639	696	*
640	697	* Data is always written to disk when #mdb_txn_commit() is called,
641		* but the operating system may keep it buffered. MDB always flushes
	698	* but the operating system may keep it buffered. LMDB always flushes
642	699	* the OS buffers upon commit as well, unless the environment was
643	700	* opened with #MDB_NOSYNC or in part #MDB_NOMETASYNC.
644	701	* @param[in] env An environment handle returned by #mdb_env_create()

667	724	/** @brief Set environment flags.
668	725	*
669	726	* This may be used to set some flags in addition to those from
670		* #mdb_env_open(), or to unset these flags.
	727	* #mdb_env_open(), or to unset these flags. If several threads
	728	* change the flags at the same time, the result is undefined.
671	729	* @param[in] env An environment handle returned by #mdb_env_create()
672	730	* @param[in] flags The flags to change, bitwise OR'ed together
673	731	* @param[in] onoff A non-zero value sets the flags, zero clears them.

728	786	* this process. Note that the library does not check for this condition,
729	787	* the caller must ensure it explicitly.
730	788	*
731		* If the mapsize is changed by another process, #mdb_txn_begin() will
	789	* The new size takes effect immediately for the current process but
	790	* will not be persisted to any others until a write transaction has been
	791	* committed by the current process. Also, only mapsize increases are
	792	* persisted into the environment.
	793	*
	794	* If the mapsize is increased by another process, and data has grown
	795	* beyond the range of the current mapsize, #mdb_txn_begin() will
732	796	* return #MDB_MAP_RESIZED. This function may be called with a size
733	797	* of zero to adopt the new size.
734	798	*

782	846	* environment. Simpler applications that use the environment as a single
783	847	* unnamed database can ignore this option.
784	848	* This function may only be called after #mdb_env_create() and before #mdb_env_open().
	849	*
	850	* Currently a moderate number of slots are cheap but a huge number gets
	851	* expensive: 7-120 words per transaction, and every #mdb_dbi_open()
	852	* does a linear search of the opened slots.
785	853	* @param[in] env An environment handle returned by #mdb_env_create()
786	854	* @param[in] dbs The maximum number of databases
787	855	* @return A non-zero error value on failure and 0 on success. Some possible

816	884	*/
817	885	void mdb_env_get_userctx(MDB_env env);
818	886
819		/** @brief A callback function for most MDB assert() failures,
	887	/** @brief A callback function for most LMDB assert() failures,
820	888	* called before printing the message and aborting.
821	889	*
822	890	* @param[in] env An environment handle returned by #mdb_env_create().

828	896	* Disabled if liblmdb is buillt with NDEBUG.
829	897	* @note This hack should become obsolete as lmdb's error handling matures.
830	898	* @param[in] env An environment handle returned by #mdb_env_create().
831		* @parem[in] func An #MDB_assert_func function, or 0.
	899	* @param[in] func An #MDB_assert_func function, or 0.
832	900	* @return A non-zero error value on failure and 0 on success.
833	901	*/
834	902	int mdb_env_set_assert(MDB_env env, MDB_assert_func func);

949	1017	* independently of whether such a database exists.
950	1018	* The database handle may be discarded by calling #mdb_dbi_close().
951	1019	* The old database handle is returned if the database was already open.
952		* The handle must only be closed once.
	1020	* The handle may only be closed once.
953	1021	* The database handle will be private to the current transaction until
954	1022	* the transaction is successfully committed. If the transaction is
955	1023	* aborted the handle will be closed automatically.

961	1029	* use this function.
962	1030	*
963	1031	* To use named databases (with name != NULL), #mdb_env_set_maxdbs()
964		* must be called before opening the environment.
	1032	* must be called before opening the environment. Database names
	1033	* are kept as keys in the unnamed database.
965	1034	* @param[in] txn A transaction handle returned by #mdb_txn_begin()
966	1035	* @param[in] name The name of the database to open. If only a single
967	1036	* database is needed in the environment, this value may be NULL.

1031	1100	*/
1032	1101	int mdb_dbi_flags(MDB_txn txn, MDB_dbi dbi, unsigned int flags);
1033	1102
1034		/** @brief Close a database handle.
	1103	/** @brief Close a database handle. Normally unnecessary. Use with care:
1035	1104	*
1036	1105	* This call is not mutex protected. Handles should only be closed by
1037	1106	* a single thread, and only if no other threads are going to reference
1038	1107	* the database handle or one of its cursors any further. Do not close
1039	1108	* a handle if an existing transaction has modified its database.
	1109	* Doing so can cause misbehavior from database corruption to errors
	1110	* like MDB_BAD_VALSIZE (since the DB name is gone).
	1111	*
	1112	* Closing a database handle is not necessary, but lets #mdb_dbi_open()
	1113	* reuse the handle value. Usually it's better to set a bigger
	1114	* #mdb_env_set_maxdbs(), unless that value would be large.
	1115	*
1040	1116	* @param[in] env An environment handle returned by #mdb_env_create()
1041	1117	* @param[in] dbi A database handle returned by #mdb_dbi_open()
1042	1118	*/

1044	1120
1045	1121	/** @brief Empty or delete+close a database.
1046	1122	*
	1123	* See #mdb_dbi_close() for restrictions about closing the DB handle.
1047	1124	* @param[in] txn A transaction handle returned by #mdb_txn_begin()
1048	1125	* @param[in] dbi A database handle returned by #mdb_dbi_open()
1049	1126	* @param[in] del 0 to empty the DB, 1 to delete it from the

1189	1266	* reserved space, which the caller can fill in later - before
1190	1267	* the next update operation or the transaction ends. This saves
1191	1268	* an extra memcpy if the data is being generated later.
1192		* MDB does nothing else with this memory, the caller is expected
	1269	* LMDB does nothing else with this memory, the caller is expected
1193	1270	* to modify all of the space requested.
1194	1271	* <li>#MDB_APPEND - append the given key/data pair to the end of the
1195	1272	* database. No key comparisons are performed. This option allows

1321	1398	/** @brief Store by cursor.
1322	1399	*
1323	1400	* This function stores key/data pairs into the database.
1324		* If the function fails for any reason, the state of the cursor will be
1325		* unchanged. If the function succeeds and an item is inserted into the
1326		* database, the cursor is always positioned to refer to the newly inserted item.
	1401	* The cursor is positioned at the new item, or on failure usually near it.
	1402	* @note Earlier documentation incorrectly said errors would leave the
	1403	* state of the cursor unchanged.
1327	1404	* @param[in] cursor A cursor handle returned by #mdb_cursor_open()
1328	1405	* @param[in] key The key operated on.
1329	1406	* @param[in] data The data operated on.
1330	1407	* @param[in] flags Options for this operation. This parameter
1331	1408	* must be set to 0 or one of the values described here.
1332	1409	* <ul>
1333		* <li>#MDB_CURRENT - overwrite the data of the key/data pair to which
1334		* the cursor refers with the specified data item. The \b key
1335		* parameter is ignored.
	1410	* <li>#MDB_CURRENT - replace the item at the current cursor position.
	1411	* The \b key parameter must still be provided, and must match it.
	1412	* If using sorted duplicates (#MDB_DUPSORT) the data item must still
	1413	* sort into the same place. This is intended to be used when the
	1414	* new data is the same size as the old. Otherwise it will simply
	1415	* perform a delete of the old record followed by an insert.
1336	1416	* <li>#MDB_NODUPDATA - enter the new key/data pair only if it does not
1337	1417	* already appear in the database. This flag may only be specified
1338	1418	* if the database was opened with #MDB_DUPSORT. The function will

1461	1541	#ifdef __cplusplus
1462	1542	}
1463	1543	#endif
	1544	/** @page tools LMDB Command Line Tools
	1545	The following describes the command line tools that are available for LMDB.
	1546	\li \ref mdb_copy_1
	1547	\li \ref mdb_dump_1
	1548	\li \ref mdb_load_1
	1549	\li \ref mdb_stat_1
	1550	*/
	1551
1464	1552	#endif /* _LMDB_H_ */

+1429

-529

libraries/liblmdb/mdb.c less more

0	0	/** @file mdb.c
1		* @brief memory-mapped database library
	1	* @brief Lightning memory-mapped database library
2	2	*
3	3	* A Btree-based database management library modeled loosely on the
4	4	* BerkeleyDB API, but much simplified.
5	5	*/
6	6	/*
7		* Copyright 2011-2013 Howard Chu, Symas Corp.
	7	* Copyright 2011-2014 Howard Chu, Symas Corp.
8	8	* All rights reserved.
9	9	*
10	10	* Redistribution and use in source and binary forms, with or without

34	34	#ifndef _GNU_SOURCE
35	35	#define _GNU_SOURCE 1
36	36	#endif
37		#include <sys/types.h>
38		#include <sys/stat.h>
39	37	#ifdef _WIN32
	38	#include <malloc.h>
40	39	#include <windows.h>
41	40	/** getpid() returns int; MinGW defines pid_t but MinGW64 typedefs it
42	41	* as int64 which is wrong. MSVC doesn't define it at all, so just
43	42	* don't use it.
44	43	*/
45	44	#define MDB_PID_T int
	45	#define MDB_THR_T DWORD
	46	#include <sys/types.h>
	47	#include <sys/stat.h>
46	48	#ifdef __GNUC__
47	49	# include <sys/param.h>
48	50	#else

54	56	# endif
55	57	#endif
56	58	#else
	59	#include <sys/types.h>
	60	#include <sys/stat.h>
57	61	#define MDB_PID_T pid_t
	62	#define MDB_THR_T pthread_t
58	63	#include <sys/param.h>
59	64	#include <sys/uio.h>
60	65	#include <sys/mman.h>

63	68	#endif
64	69	#include <fcntl.h>
65	70	#endif
	71
	72	#if defined(__mips) && defined(__linux)
	73	/* MIPS has cache coherency issues, requires explicit cache control */
	74	#include <asm/cachectl.h>
	75	extern int cacheflush(char *addr, int nbytes, int cache);
	76	#define CACHEFLUSH(addr, bytes, cache) cacheflush(addr, bytes, cache)
	77	#else
	78	#define CACHEFLUSH(addr, bytes, cache)
	79	#endif
	80
66	81
67	82	#include <errno.h>
68	83	#include <limits.h>

73	88	#include <string.h>
74	89	#include <time.h>
75	90	#include <unistd.h>
	91
	92	#if defined(__sun)
	93	/* Most platforms have posix_memalign, older may only have memalign */
	94	#define HAVE_MEMALIGN 1
	95	#include <malloc.h>
	96	#endif
76	97
77	98	#if !(defined(BYTE_ORDER) \|\| defined(__BYTE_ORDER))
78	99	#include <netinet/in.h>

144	165	# error "Two's complement, reasonably sized integer types, please"
145	166	#endif
146	167
147		/** @defgroup internal MDB Internals
	168	#ifdef __GNUC__
	169	/** Put infrequently used env functions in separate section */
	170	# ifdef __APPLE__
	171	# define ESECT __attribute__ ((section("__TEXT,text_env")))
	172	# else
	173	# define ESECT __attribute__ ((section("text_env")))
	174	# endif
	175	#else
	176	#define ESECT
	177	#endif
	178
	179	/** @defgroup internal LMDB Internals
148	180	* @{
149	181	*/
150	182	/** @defgroup compat Compatibility Macros

155	187	* @{
156	188	*/
157	189
	190	/** Features under development */
	191	#ifndef MDB_DEVEL
	192	#define MDB_DEVEL 0
	193	#endif
	194
158	195	/** Wrapper around __func__, which is a C99 feature */
159	196	#if __STDC_VERSION__ >= 199901L
160	197	# define mdb_func_ __func__

168	205	#ifdef _WIN32
169	206	#define MDB_USE_HASH 1
170	207	#define MDB_PIDLOCK 0
171		#define pthread_t DWORD
	208	#define THREAD_RET DWORD
	209	#define pthread_t HANDLE
172	210	#define pthread_mutex_t HANDLE
	211	#define pthread_cond_t HANDLE
173	212	#define pthread_key_t DWORD
174	213	#define pthread_self() GetCurrentThreadId()
175	214	#define pthread_key_create(x,y) \

177	216	#define pthread_key_delete(x) TlsFree(x)
178	217	#define pthread_getspecific(x) TlsGetValue(x)
179	218	#define pthread_setspecific(x,y) (TlsSetValue(x,y) ? 0 : ErrCode())
180		#define pthread_mutex_unlock(x) ReleaseMutex(x)
181		#define pthread_mutex_lock(x) WaitForSingleObject(x, INFINITE)
182		#define LOCK_MUTEX_R(env) pthread_mutex_lock((env)->me_rmutex)
183		#define UNLOCK_MUTEX_R(env) pthread_mutex_unlock((env)->me_rmutex)
184		#define LOCK_MUTEX_W(env) pthread_mutex_lock((env)->me_wmutex)
185		#define UNLOCK_MUTEX_W(env) pthread_mutex_unlock((env)->me_wmutex)
	219	#define pthread_mutex_unlock(x) ReleaseMutex(*x)
	220	#define pthread_mutex_lock(x) WaitForSingleObject(*x, INFINITE)
	221	#define pthread_cond_signal(x) SetEvent(*x)
	222	#define pthread_cond_wait(cond,mutex) do{SignalObjectAndWait(mutex, cond, INFINITE, FALSE); WaitForSingleObject(*mutex, INFINITE);}while(0)
	223	#define THREAD_CREATE(thr,start,arg) thr=CreateThread(NULL,0,start,arg,0,NULL)
	224	#define THREAD_FINISH(thr) WaitForSingleObject(thr, INFINITE)
	225	#define LOCK_MUTEX_R(env) pthread_mutex_lock(&(env)->me_rmutex)
	226	#define UNLOCK_MUTEX_R(env) pthread_mutex_unlock(&(env)->me_rmutex)
	227	#define LOCK_MUTEX_W(env) pthread_mutex_lock(&(env)->me_wmutex)
	228	#define UNLOCK_MUTEX_W(env) pthread_mutex_unlock(&(env)->me_wmutex)
186	229	#define getpid() GetCurrentProcessId()
187	230	#define MDB_FDATASYNC(fd) (!FlushFileBuffers(fd))
188	231	#define MDB_MSYNC(addr,len,flags) (!FlushViewOfFile(addr,len))

197	240	#endif
198	241	#define Z "I"
199	242	#else
200
	243	#define THREAD_RET void *
	244	#define THREAD_CREATE(thr,start,arg) pthread_create(&thr,NULL,start,arg)
	245	#define THREAD_FINISH(thr) pthread_join(thr,NULL)
201	246	#define Z "z" /*< printf format modifier for size_t /
202	247
203	248	/** For MDB_LOCK_FORMAT: True if readers take a pid lock in the lockfile */

351	396
352	397	/** @brief The maximum size of a database page.
353	398	*
354		* This is 32k, since it must fit in #MDB_page.#mp_upper.
	399	* It is 32k or 64k, since value-PAGEBASE must fit in
	400	* #MDB_page.%mp_upper.
355	401	*
356	402	* LMDB will use database pages < OS pages if needed.
357	403	* That causes more I/O in write transactions: The OS must

364	410	* pressure from other processes is high. So until OSs have
365	411	* actual paging support for Huge pages, they're not viable.
366	412	*/
367		#define MAX_PAGESIZE 0x8000
	413	#define MAX_PAGESIZE (PAGEBASE ? 0x10000 : 0x8000)
368	414
369	415	/** The minimum number of keys required in a database page.
370	416	* Setting this to a larger value will place a smaller bound on the

380	426	*/
381	427	#define MDB_MINKEYS 2
382	428
383		/** A stamp that identifies a file as an MDB file.
	429	/** A stamp that identifies a file as an LMDB file.
384	430	* There's nothing special about this value other than that it is easily
385	431	* recognizable, and it will reflect any byte order mismatches.
386	432	*/
387	433	#define MDB_MAGIC 0xBEEFC0DE
388	434
389	435	/** The version number for a database's datafile format. */
390		#define MDB_DATA_VERSION 1
	436	#define MDB_DATA_VERSION ((MDB_DEVEL) ? 999 : 1)
391	437	/** The version number for a database's lockfile format. */
392	438	#define MDB_LOCK_VERSION 1
393	439

396	442	* Define this as 0 to compute the max from the page size. 511
397	443	* is default for backwards compat: liblmdb <= 0.9.10 can break
398	444	* when modifying a DB with keys/dupsort data bigger than its max.
	445	* #MDB_DEVEL sets the default to 0.
399	446	*
400	447	* Data items in an #MDB_DUPSORT database are also limited to
401	448	* this size, since they're actually keys of a sub-DB. Keys and
402	449	* #MDB_DUPSORT data items must fit on a node in a regular page.
403	450	*/
404	451	#ifndef MDB_MAXKEYSIZE
405		#define MDB_MAXKEYSIZE 511
	452	#define MDB_MAXKEYSIZE ((MDB_DEVEL) ? 0 : 511)
406	453	#endif
407	454
408	455	/** The maximum size of a key we can write to the environment. */

536	583	/** The process ID of the process owning this reader txn. */
537	584	MDB_PID_T mrb_pid;
538	585	/** The thread ID of the thread owning this txn. */
539		pthread_t mrb_tid;
	586	MDB_THR_T mrb_tid;
540	587	} MDB_rxbody;
541	588
542	589	/** The actual reader record, with cacheline padding. */

567	614	* unlikely. If a collision occurs, the results are unpredictable.
568	615	*/
569	616	typedef struct MDB_txbody {
570		/** Stamp identifying this as an MDB file. It must be set
	617	/** Stamp identifying this as an LMDB file. It must be set
571	618	* to #MDB_MAGIC. */
572	619	uint32_t mtb_magic;
573	620	/** Format of this lock file. Must be set to #MDB_LOCK_FORMAT. */

634	681	#define mp_next mp_p.p_next
635	682	union {
636	683	pgno_t p_pgno; /*< page number /
637		void * p_next; /*< for in-memory list of freed structs /
	684	struct MDB_page p_next; /< for in-memory list of freed pages /
638	685	} mp_p;
639	686	uint16_t mp_pad;
640	687	/** @defgroup mdb_page Page Flags

649	696	#define P_DIRTY 0x10 /*< dirty page, also set for #P_SUBP pages /
650	697	#define P_LEAF2 0x20 /*< for #MDB_DUPFIXED records /
651	698	#define P_SUBP 0x40 /*< for #MDB_DUPSORT sub-pages /
	699	#define P_LOOSE 0x4000 /*< page was dirtied then freed, can be reused /
652	700	#define P_KEEP 0x8000 /*< leave this page alone during spill /
653	701	/** @} */
654	702	uint16_t mp_flags; /*< @ref mdb_page /

671	719	/** Address of first usable data byte in a page, after the header */
672	720	#define METADATA(p) ((void )((char )(p) + PAGEHDRSZ))
673	721
	722	/** ITS#7713, change PAGEBASE to handle 65536 byte pages */
	723	#define PAGEBASE ((MDB_DEVEL) ? PAGEHDRSZ : 0)
	724
674	725	/** Number of nodes on a page */
675		#define NUMKEYS(p) (((p)->mp_lower - PAGEHDRSZ) >> 1)
	726	#define NUMKEYS(p) (((p)->mp_lower - (PAGEHDRSZ-PAGEBASE)) >> 1)
676	727
677	728	/** The amount of space remaining in the page */
678	729	#define SIZELEFT(p) (indx_t)((p)->mp_upper - (p)->mp_lower)

698	749
699	750	/** The number of overflow pages needed to store the given size. */
700	751	#define OVPAGES(size, psize) ((PAGEHDRSZ-1 + (size)) / (psize) + 1)
	752
	753	/** Link in #MDB_txn.%mt_loose_pgs list */
	754	#define NEXT_LOOSE_PAGE(p) ((MDB_page *)((p) + 2))
701	755
702	756	/** Header for a single key/data pair within a page.
703	757	* Used in pages of type #P_BRANCH and #P_LEAF without #P_LEAF2.

750	804	#define LEAFSIZE(k, d) (NODESIZE + (k)->mv_size + (d)->mv_size)
751	805
752	806	/** Address of node \b i in page \b p */
753		#define NODEPTR(p, i) ((MDB_node )((char )(p) + (p)->mp_ptrs[i]))
	807	#define NODEPTR(p, i) ((MDB_node )((char )(p) + (p)->mp_ptrs[i] + PAGEBASE))
754	808
755	809	/** Address of the key for the node */
756	810	#define NODEKEY(node) (void *)((node)->mn_data)

840	894	* Pages 0-1 are meta pages. Transaction N writes meta page #(N % 2).
841	895	*/
842	896	typedef struct MDB_meta {
843		/** Stamp identifying this as an MDB file. It must be set
	897	/** Stamp identifying this as an LMDB file. It must be set
844	898	* to #MDB_MAGIC. */
845	899	uint32_t mm_magic;
846	900	/** Version number of this lock file. Must be set to #MDB_DATA_VERSION. */

897	951	/** The list of pages that became unused during this transaction.
898	952	*/
899	953	MDB_IDL mt_free_pgs;
	954	/** The list of loose pages that became unused and may be reused
	955	* in this transaction, linked through #NEXT_LOOSE_PAGE(page).
	956	*/
	957	MDB_page *mt_loose_pgs;
	958	/* #Number of loose pages (#mt_loose_pgs) */
	959	int mt_loose_count;
900	960	/** The sorted list of dirty pages we temporarily wrote to disk
901	961	* because the dirty list was full. page numbers in here are
902	962	* shifted left by 1, deleted slots have the LSB set.

912	972	MDB_dbx *mt_dbxs;
913	973	/** Array of MDB_db records for each known DB */
914	974	MDB_db *mt_dbs;
	975	/** Array of sequence numbers for each DB handle */
	976	unsigned int *mt_dbiseqs;
915	977	/** @defgroup mt_dbflag Transaction DB Flags
916	978	* @ingroup internal
917	979	* @{

935	997	* @{
936	998	*/
937	999	#define MDB_TXN_RDONLY 0x01 /*< read-only transaction /
938		#define MDB_TXN_ERROR 0x02 /*< an error has occurred /
	1000	#define MDB_TXN_ERROR 0x02 /*< txn is unusable after an error /
939	1001	#define MDB_TXN_DIRTY 0x04 /*< must write, even if dirty list is empty /
940	1002	#define MDB_TXN_SPILLS 0x08 /*< txn or a parent has spilled pages /
941	1003	/** @} */
942	1004	unsigned int mt_flags; /*< @ref mdb_txn /
943		/** dirty_list room: Array size - #dirty pages visible to this txn.
	1005	/** #dirty_list room: Array size - \#dirty pages visible to this txn.
944	1006	* Includes ancestor txns' dirty pages not hidden by other txns'
945	1007	* dirty/spilled pages. Thus commit(nested txn) has room to merge
946	1008	* dirty_list into mt_parent after freeing hidden mt_parent pages.

1033	1095	#define MDB_ENV_ACTIVE 0x20000000U
1034	1096	/** me_txkey is set */
1035	1097	#define MDB_ENV_TXKEY 0x10000000U
1036		/** Have liveness lock in reader table */
1037		#define MDB_LIVE_READER 0x08000000U
1038	1098	uint32_t me_flags; /*< @ref mdb_env /
1039	1099	unsigned int me_psize; /*< DB page size, inited from me_os_psize /
1040	1100	unsigned int me_os_psize; /*< OS page size, from #GET_PAGESIZE /

1049	1109	MDB_meta me_metas[2]; /< pointers to the two meta pages /
1050	1110	void me_pbuf; /< scratch area for DUPSORT put() /
1051	1111	MDB_txn me_txn; /< current write transaction /
	1112	MDB_txn me_txn0; /< prealloc'd write transaction /
1052	1113	size_t me_mapsize; /*< size of the data memory map /
1053	1114	off_t me_size; /*< current file size /
1054	1115	pgno_t me_maxpg; /*< me_mapsize / me_psize /
1055	1116	MDB_dbx me_dbxs; /< array of static DB info /
1056	1117	uint16_t me_dbflags; /< array of flags from MDB_db.md_flags /
	1118	unsigned int me_dbiseqs; /< array of dbi sequence numbers /
1057	1119	pthread_key_t me_txkey; /*< thread-key for readers /
	1120	txnid_t me_pgoldest; /*< ID of oldest reader last time we looked /
1058	1121	MDB_pgstate me_pgstate; /*< state of old pages from freeDB /
1059	1122	# define me_pglast me_pgstate.mf_pglast
1060	1123	# define me_pghead me_pgstate.mf_pghead

1070	1133	#if !(MDB_MAXKEYSIZE)
1071	1134	unsigned int me_maxkey; /*< max size of a key /
1072	1135	#endif
	1136	int me_live_reader; /*< have liveness lock in reader table /
1073	1137	#ifdef _WIN32
1074	1138	int me_pidquery; /*< Used in OpenProcess /
1075	1139	HANDLE me_rmutex; /* Windows mutexes don't reside in shared mem */

1095	1159	#define MDB_COMMIT_PAGES IOV_MAX
1096	1160	#endif
1097	1161
1098		/* max bytes to write in one call */
	1162	/** max bytes to write in one call */
1099	1163	#define MAX_WRITE (0x80000000U >> (sizeof(ssize_t) == 4))
	1164
	1165	/** Check \b txn and \b dbi arguments to a function */
	1166	#define TXN_DBI_EXIST(txn, dbi) \
	1167	((txn) && (dbi) < (txn)->mt_numdbs && ((txn)->mt_dbflags[dbi] & DB_VALID))
	1168
	1169	/** Check for misused \b dbi handles */
	1170	#define TXN_DBI_CHANGED(txn, dbi) \
	1171	((txn)->mt_dbiseqs[dbi] != (txn)->mt_env->me_dbiseqs[dbi])
1100	1172
1101	1173	static int mdb_page_alloc(MDB_cursor mc, int num, MDB_page *mp);
1102	1174	static int mdb_page_new(MDB_cursor mc, uint32_t flags, int num, MDB_page *mp);

1141	1213	static void mdb_cursor_pop(MDB_cursor *mc);
1142	1214	static int mdb_cursor_push(MDB_cursor mc, MDB_page mp);
1143	1215
1144		static int mdb_cursor_del0(MDB_cursor mc, MDB_node leaf);
	1216	static int mdb_cursor_del0(MDB_cursor *mc);
	1217	static int mdb_del0(MDB_txn txn, MDB_dbi dbi, MDB_val key, MDB_val *data, unsigned flags);
1145	1218	static int mdb_cursor_sibling(MDB_cursor *mc, int move_right);
1146	1219	static int mdb_cursor_next(MDB_cursor mc, MDB_val key, MDB_val *data, MDB_cursor_op op);
1147	1220	static int mdb_cursor_prev(MDB_cursor mc, MDB_val key, MDB_val *data, MDB_cursor_op op);

1177	1250	return MDB_VERSION_STRING;
1178	1251	}
1179	1252
1180		/** Table of descriptions for MDB @ref errors */
	1253	/** Table of descriptions for LMDB @ref errors */
1181	1254	static char *const mdb_errstr[] = {
1182	1255	"MDB_KEYEXIST: Key/data pair already exists",
1183	1256	"MDB_NOTFOUND: No matching key/data pair found",

1185	1258	"MDB_CORRUPTED: Located page was wrong type",
1186	1259	"MDB_PANIC: Update of meta page failed",
1187	1260	"MDB_VERSION_MISMATCH: Database environment version mismatch",
1188		"MDB_INVALID: File is not an MDB file",
	1261	"MDB_INVALID: File is not an LMDB file",
1189	1262	"MDB_MAP_FULL: Environment mapsize limit reached",
1190	1263	"MDB_DBS_FULL: Environment maxdbs limit reached",
1191	1264	"MDB_READERS_FULL: Environment maxreaders limit reached",

1197	1270	"MDB_INCOMPATIBLE: Operation and DB incompatible, or DB flags changed",
1198	1271	"MDB_BAD_RSLOT: Invalid reuse of reader locktable slot",
1199	1272	"MDB_BAD_TXN: Transaction cannot recover - it must be aborted",
1200		"MDB_BAD_VALSIZE: Too big key/data, key is empty, or wrong DUPFIXED size",
	1273	"MDB_BAD_VALSIZE: Unsupported size of key/DB name/data, or wrong DUPFIXED size",
	1274	"MDB_BAD_DBI: The specified DBI handle was closed/changed unexpectedly",
1201	1275	};
1202	1276
1203	1277	char *
1204	1278	mdb_strerror(int err)
1205	1279	{
	1280	#ifdef _WIN32
	1281	/** HACK: pad 4KB on stack over the buf. Return system msgs in buf.
	1282	* This works as long as no function between the call to mdb_strerror
	1283	* and the actual use of the message uses more than 4K of stack.
	1284	*/
	1285	char pad[4096];
	1286	char buf[1024], *ptr = buf;
	1287	#endif
1206	1288	int i;
1207	1289	if (!err)
1208	1290	return ("Successful return: 0");

1212	1294	return mdb_errstr[i];
1213	1295	}
1214	1296
	1297	#ifdef _WIN32
	1298	/* These are the C-runtime error codes we use. The comment indicates
	1299	* their numeric value, and the Win32 error they would correspond to
	1300	* if the error actually came from a Win32 API. A major mess, we should
	1301	* have used LMDB-specific error codes for everything.
	1302	*/
	1303	switch(err) {
	1304	case ENOENT: /* 2, FILE_NOT_FOUND */
	1305	case EIO: /* 5, ACCESS_DENIED */
	1306	case ENOMEM: /* 12, INVALID_ACCESS */
	1307	case EACCES: /* 13, INVALID_DATA */
	1308	case EBUSY: /* 16, CURRENT_DIRECTORY */
	1309	case EINVAL: /* 22, BAD_COMMAND */
	1310	case ENOSPC: /* 28, OUT_OF_PAPER */
	1311	return strerror(err);
	1312	default:
	1313	;
	1314	}
	1315	buf[0] = 0;
	1316	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM \|
	1317	FORMAT_MESSAGE_IGNORE_INSERTS,
	1318	NULL, err, 0, ptr, sizeof(buf), pad);
	1319	return ptr;
	1320	#else
1215	1321	return strerror(err);
	1322	#endif
1216	1323	}
1217	1324
1218	1325	/** assert(3) variant in cursor context */

1282	1389	return buf;
1283	1390	}
1284	1391
	1392	static const char *
	1393	mdb_leafnode_type(MDB_node *n)
	1394	{
	1395	static char *const tp[2][2] = {{"", ": DB"}, {": sub-page", ": sub-DB"}};
	1396	return F_ISSET(n->mn_flags, F_BIGDATA) ? ": overflow page" :
	1397	tp[F_ISSET(n->mn_flags, F_DUPDATA)][F_ISSET(n->mn_flags, F_SUBDATA)];
	1398	}
	1399
1285	1400	/** Display all the keys in the page. */
1286	1401	void
1287	1402	mdb_page_list(MDB_page *mp)
1288	1403	{
	1404	pgno_t pgno = mdb_dbg_pgno(mp);
	1405	const char type, state = (mp->mp_flags & P_DIRTY) ? ", dirty" : "";
1289	1406	MDB_node *node;
1290	1407	unsigned int i, nkeys, nsize, total = 0;
1291	1408	MDB_val key;
1292	1409	DKBUF;
1293	1410
	1411	switch (mp->mp_flags & (P_BRANCH\|P_LEAF\|P_LEAF2\|P_META\|P_OVERFLOW\|P_SUBP)) {
	1412	case P_BRANCH: type = "Branch page"; break;
	1413	case P_LEAF: type = "Leaf page"; break;
	1414	case P_LEAF\|P_SUBP: type = "Sub-page"; break;
	1415	case P_LEAF\|P_LEAF2: type = "LEAF2 page"; break;
	1416	case P_LEAF\|P_LEAF2\|P_SUBP: type = "LEAF2 sub-page"; break;
	1417	case P_OVERFLOW:
	1418	fprintf(stderr, "Overflow page %"Z"u pages %u%s\n",
	1419	pgno, mp->mp_pages, state);
	1420	return;
	1421	case P_META:
	1422	fprintf(stderr, "Meta-page %"Z"u txnid %"Z"u\n",
	1423	pgno, ((MDB_meta *)METADATA(mp))->mm_txnid);
	1424	return;
	1425	default:
	1426	fprintf(stderr, "Bad page %"Z"u flags 0x%u\n", pgno, mp->mp_flags);
	1427	return;
	1428	}
	1429
1294	1430	nkeys = NUMKEYS(mp);
1295		fprintf(stderr, "Page %"Z"u numkeys %d\n", mdb_dbg_pgno(mp), nkeys);
	1431	fprintf(stderr, "%s %"Z"u numkeys %d%s\n", type, pgno, nkeys, state);
	1432
1296	1433	for (i=0; i<nkeys; i++) {
	1434	if (IS_LEAF2(mp)) { /* LEAF2 pages have no mp_ptrs[] or node headers */
	1435	key.mv_size = nsize = mp->mp_pad;
	1436	key.mv_data = LEAF2KEY(mp, i, nsize);
	1437	total += nsize;
	1438	fprintf(stderr, "key %d: nsize %d, %s\n", i, nsize, DKEY(&key));
	1439	continue;
	1440	}
1297	1441	node = NODEPTR(mp, i);
1298	1442	key.mv_size = node->mn_ksize;
1299	1443	key.mv_data = node->mn_data;

1309	1453	nsize += NODEDSZ(node);
1310	1454	total += nsize;
1311	1455	nsize += sizeof(indx_t);
1312		fprintf(stderr, "key %d: nsize %d, %s\n", i, nsize, DKEY(&key));
	1456	fprintf(stderr, "key %d: nsize %d, %s%s\n",
	1457	i, nsize, DKEY(&key), mdb_leafnode_type(node));
1313	1458	}
1314	1459	total = EVEN(total);
1315	1460	}
1316		fprintf(stderr, "Total: %d\n", total);
	1461	fprintf(stderr, "Total: header %d + contents %d + unused %d\n",
	1462	IS_LEAF2(mp) ? PAGEHDRSZ : PAGEBASE + mp->mp_lower, total, SIZELEFT(mp));
1317	1463	}
1318	1464
1319	1465	void

1339	1485	/** Count all the pages in each DB and in the freelist
1340	1486	* and make sure it matches the actual number of pages
1341	1487	* being used.
	1488	* All named DBs must be open for a correct count.
1342	1489	*/
1343	1490	static void mdb_audit(MDB_txn *txn)
1344	1491	{

1352	1499	mdb_cursor_init(&mc, txn, FREE_DBI, NULL);
1353	1500	while ((rc = mdb_cursor_get(&mc, &key, &data, MDB_NEXT)) == 0)
1354	1501	freecount += (MDB_ID )data.mv_data;
	1502	mdb_tassert(txn, rc == MDB_NOTFOUND);
1355	1503
1356	1504	count = 0;
1357	1505	for (i = 0; i<txn->mt_numdbs; i++) {
1358	1506	MDB_xcursor mx;
	1507	if (!(txn->mt_dbflags[i] & DB_VALID))
	1508	continue;
1359	1509	mdb_cursor_init(&mc, txn, i, &mx);
1360	1510	if (txn->mt_dbs[i].md_root == P_INVALID)
1361	1511	continue;

1363	1513	txn->mt_dbs[i].md_leaf_pages +
1364	1514	txn->mt_dbs[i].md_overflow_pages;
1365	1515	if (txn->mt_dbs[i].md_flags & MDB_DUPSORT) {
1366		mdb_page_search(&mc, NULL, MDB_PS_FIRST);
1367		do {
	1516	rc = mdb_page_search(&mc, NULL, MDB_PS_FIRST);
	1517	for (; rc == MDB_SUCCESS; rc = mdb_cursor_sibling(&mc, 1)) {
1368	1518	unsigned j;
1369	1519	MDB_page *mp;
1370	1520	mp = mc.mc_pg[mc.mc_top];

1378	1528	}
1379	1529	}
1380	1530	}
1381		while (mdb_cursor_sibling(&mc, 1) == 0);
	1531	mdb_tassert(txn, rc == MDB_NOTFOUND);
1382	1532	}
1383	1533	}
1384	1534	if (freecount + count + 2 /* metapages */ != txn->mt_next_pgno) {

1437	1587	}
1438	1588	return ret;
1439	1589	}
1440
1441	1590	/** Free a single page.
1442	1591	* Saves single pages to a list, for future reuse.
1443	1592	* (This is not used for multi-page overflow pages.)

1475	1624	mdb_dpage_free(env, dl[i].mptr);
1476	1625	}
1477	1626	dl[0].mid = 0;
	1627	}
	1628
	1629	/** Loosen or free a single page.
	1630	* Saves single pages to a list for future reuse
	1631	* in this same txn. It has been pulled from the freeDB
	1632	* and already resides on the dirty list, but has been
	1633	* deleted. Use these pages first before pulling again
	1634	* from the freeDB.
	1635	*
	1636	* If the page wasn't dirtied in this txn, just add it
	1637	* to this txn's free list.
	1638	*/
	1639	static int
	1640	mdb_page_loose(MDB_cursor mc, MDB_page mp)
	1641	{
	1642	int loose = 0;
	1643	pgno_t pgno = mp->mp_pgno;
	1644	MDB_txn *txn = mc->mc_txn;
	1645
	1646	if ((mp->mp_flags & P_DIRTY) && mc->mc_dbi != FREE_DBI) {
	1647	if (txn->mt_parent) {
	1648	MDB_ID2 *dl = txn->mt_u.dirty_list;
	1649	/* If txn has a parent, make sure the page is in our
	1650	* dirty list.
	1651	*/
	1652	if (dl[0].mid) {
	1653	unsigned x = mdb_mid2l_search(dl, pgno);
	1654	if (x <= dl[0].mid && dl[x].mid == pgno) {
	1655	if (mp != dl[x].mptr) { /* bad cursor? */
	1656	mc->mc_flags &= ~(C_INITIALIZED\|C_EOF);
	1657	txn->mt_flags \|= MDB_TXN_ERROR;
	1658	return MDB_CORRUPTED;
	1659	}
	1660	/* ok, it's ours */
	1661	loose = 1;
	1662	}
	1663	}
	1664	} else {
	1665	/* no parent txn, so it's just ours */
	1666	loose = 1;
	1667	}
	1668	}
	1669	if (loose) {
	1670	DPRINTF(("loosen db %d page %"Z"u", DDBI(mc),
	1671	mp->mp_pgno));
	1672	NEXT_LOOSE_PAGE(mp) = txn->mt_loose_pgs;
	1673	txn->mt_loose_pgs = mp;
	1674	txn->mt_loose_count++;
	1675	mp->mp_flags \|= P_LOOSE;
	1676	} else {
	1677	int rc = mdb_midl_append(&txn->mt_free_pgs, pgno);
	1678	if (rc)
	1679	return rc;
	1680	}
	1681
	1682	return MDB_SUCCESS;
1478	1683	}
1479	1684
1480	1685	/** Set or clear P_KEEP in dirty, non-overflow, non-sub pages watched by txn.

1487	1692	static int
1488	1693	mdb_pages_xkeep(MDB_cursor *mc, unsigned pflags, int all)
1489	1694	{
1490		enum { Mask = P_SUBP\|P_DIRTY\|P_KEEP };
	1695	enum { Mask = P_SUBP\|P_DIRTY\|P_LOOSE\|P_KEEP };
1491	1696	MDB_txn *txn = mc->mc_txn;
1492	1697	MDB_cursor *m3;
1493	1698	MDB_xcursor *mx;

1638	1843	for (i=dl[0].mid; i && need; i--) {
1639	1844	MDB_ID pn = dl[i].mid << 1;
1640	1845	dp = dl[i].mptr;
1641		if (dp->mp_flags & P_KEEP)
	1846	if (dp->mp_flags & (P_LOOSE\|P_KEEP))
1642	1847	continue;
1643	1848	/* Can't spill twice, make sure it's not already in a parent's
1644	1849	* spill list.

1742	1947	#else
1743	1948	enum { Paranoid = 0, Max_retries = INT_MAX /infinite/ };
1744	1949	#endif
1745		int rc, retry = Max_retries;
	1950	int rc, retry = num * 60;
1746	1951	MDB_txn *txn = mc->mc_txn;
1747	1952	MDB_env *env = txn->mt_env;
1748	1953	pgno_t pgno, *mop = env->me_pghead;
1749		unsigned i, j, k, mop_len = mop ? mop[0] : 0, n2 = num-1;
	1954	unsigned i, j, mop_len = mop ? mop[0] : 0, n2 = num-1;
1750	1955	MDB_page *np;
1751	1956	txnid_t oldest = 0, last;
1752	1957	MDB_cursor_op op;
1753	1958	MDB_cursor m2;
	1959	int found_old = 0;
	1960
	1961	/* If there are any loose pages, just use them */
	1962	if (num == 1 && txn->mt_loose_pgs) {
	1963	np = txn->mt_loose_pgs;
	1964	txn->mt_loose_pgs = NEXT_LOOSE_PAGE(np);
	1965	txn->mt_loose_count--;
	1966	DPRINTF(("db %d use loose page %"Z"u", DDBI(mc),
	1967	np->mp_pgno));
	1968	*mp = np;
	1969	return MDB_SUCCESS;
	1970	}
1754	1971
1755	1972	*mp = NULL;
1756	1973

1763	1980	for (op = MDB_FIRST;; op = MDB_NEXT) {
1764	1981	MDB_val key, data;
1765	1982	MDB_node *leaf;
1766		pgno_t *idl, old_id, new_id;
	1983	pgno_t *idl;
1767	1984
1768	1985	/* Seek a big enough contiguous page range. Prefer
1769	1986	* pages at the tail, just truncating the list.

1775	1992	if (mop[i-n2] == pgno+n2)
1776	1993	goto search_done;
1777	1994	} while (--i > n2);
1778		if (Max_retries < INT_MAX && --retry < 0)
	1995	if (--retry < 0)
1779	1996	break;
1780	1997	}
1781	1998
1782	1999	if (op == MDB_FIRST) { /* 1st iteration */
1783	2000	/* Prepare to fetch more and coalesce */
1784		oldest = mdb_find_oldest(txn);
1785	2001	last = env->me_pglast;
	2002	oldest = env->me_pgoldest;
1786	2003	mdb_cursor_init(&m2, txn, FREE_DBI, NULL);
1787	2004	if (last) {
1788	2005	op = MDB_SET_RANGE;

1797	2014
1798	2015	last++;
1799	2016	/* Do not fetch more if the record will be too recent */
1800		if (oldest <= last)
1801		break;
	2017	if (oldest <= last) {
	2018	if (!found_old) {
	2019	oldest = mdb_find_oldest(txn);
	2020	env->me_pgoldest = oldest;
	2021	found_old = 1;
	2022	}
	2023	if (oldest <= last)
	2024	break;
	2025	}
1802	2026	rc = mdb_cursor_get(&m2, &key, NULL, op);
1803	2027	if (rc) {
1804	2028	if (rc == MDB_NOTFOUND)

1806	2030	goto fail;
1807	2031	}
1808	2032	last = (txnid_t)key.mv_data;
1809		if (oldest <= last)
1810		break;
	2033	if (oldest <= last) {
	2034	if (!found_old) {
	2035	oldest = mdb_find_oldest(txn);
	2036	env->me_pgoldest = oldest;
	2037	found_old = 1;
	2038	}
	2039	if (oldest <= last)
	2040	break;
	2041	}
1811	2042	np = m2.mc_pg[m2.mc_top];
1812	2043	leaf = NODEPTR(np, m2.mc_ki[m2.mc_top]);
1813	2044	if ((rc = mdb_node_read(txn, leaf, &data)) != MDB_SUCCESS)

1829	2060	#if (MDB_DEBUG) > 1
1830	2061	DPRINTF(("IDL read txn %"Z"u root %"Z"u num %u",
1831	2062	last, txn->mt_dbs[FREE_DBI].md_root, i));
1832		for (k = i; k; k--)
1833		DPRINTF(("IDL %"Z"u", idl[k]));
	2063	for (j = i; j; j--)
	2064	DPRINTF(("IDL %"Z"u", idl[j]));
1834	2065	#endif
1835	2066	/* Merge in descending sorted order */
1836		j = mop_len;
1837		k = mop_len += i;
1838		mop[0] = (pgno_t)-1;
1839		old_id = mop[j];
1840		while (i) {
1841		new_id = idl[i--];
1842		for (; old_id < new_id; old_id = mop[--j])
1843		mop[k--] = old_id;
1844		mop[k--] = new_id;
1845		}
1846		mop[0] = mop_len;
	2067	mdb_midl_xmerge(mop, idl);
	2068	mop_len = mop[0];
1847	2069	}
1848	2070
1849	2071	/* Use new pages from the map when nothing suitable in the freeDB */

1898	2120	* alignment so memcpy may copy words instead of bytes.
1899	2121	*/
1900	2122	if ((unused &= -Align) && !IS_LEAF2(src)) {
1901		upper &= -Align;
1902		memcpy(dst, src, (lower + (Align-1)) & -Align);
	2123	upper = (upper + PAGEBASE) & -Align;
	2124	memcpy(dst, src, (lower + PAGEBASE + (Align-1)) & -Align);
1903	2125	memcpy((pgno_t )((char )dst+upper), (pgno_t )((char )src+upper),
1904	2126	psize - upper);
1905	2127	} else {

2058	2280	if (m2->mc_pg[mc->mc_top] == mp) {
2059	2281	m2->mc_pg[mc->mc_top] = np;
2060	2282	if ((mc->mc_db->md_flags & MDB_DUPSORT) &&
	2283	IS_LEAF(np) &&
2061	2284	m2->mc_ki[mc->mc_top] == mc->mc_ki[mc->mc_top])
2062	2285	{
2063	2286	MDB_node *leaf = NODEPTR(np, mc->mc_ki[mc->mc_top]);

2265	2488	return MDB_BAD_RSLOT;
2266	2489	} else {
2267	2490	MDB_PID_T pid = env->me_pid;
2268		pthread_t tid = pthread_self();
2269
2270		if (!(env->me_flags & MDB_LIVE_READER)) {
	2491	MDB_THR_T tid = pthread_self();
	2492
	2493	if (!env->me_live_reader) {
2271	2494	rc = mdb_reader_pid(env, Pidset, pid);
2272	2495	if (rc)
2273	2496	return rc;
2274		env->me_flags \|= MDB_LIVE_READER;
	2497	env->me_live_reader = 1;
2275	2498	}
2276	2499
2277	2500	LOCK_MUTEX_R(env);

2324	2547	txn->mt_free_pgs[0] = 0;
2325	2548	txn->mt_spill_pgs = NULL;
2326	2549	env->me_txn = txn;
	2550	memcpy(txn->mt_dbiseqs, env->me_dbiseqs, env->me_maxdbs * sizeof(unsigned int));
2327	2551	}
2328	2552
2329	2553	/* Copy the DB info and flags */

2398	2622	tsize = sizeof(MDB_ntxn);
2399	2623	}
2400	2624	size = tsize + env->me_maxdbs * (sizeof(MDB_db)+1);
2401		if (!(flags & MDB_RDONLY))
	2625	if (!(flags & MDB_RDONLY)) {
	2626	if (!parent) {
	2627	txn = env->me_txn0;
	2628	txn->mt_flags = 0;
	2629	goto ok;
	2630	}
2402	2631	size += env->me_maxdbs * sizeof(MDB_cursor *);
	2632	/* child txns use parent's dbiseqs */
	2633	if (!parent)
	2634	size += env->me_maxdbs * sizeof(unsigned int);
	2635	}
2403	2636
2404	2637	if ((txn = calloc(1, size)) == NULL) {
2405		DPRINTF(("calloc: %s", strerror(ErrCode())));
	2638	DPRINTF(("calloc: %s", strerror(errno)));
2406	2639	return ENOMEM;
2407	2640	}
2408	2641	txn->mt_dbs = (MDB_db ) ((char )txn + tsize);
2409	2642	if (flags & MDB_RDONLY) {
2410	2643	txn->mt_flags \|= MDB_TXN_RDONLY;
2411	2644	txn->mt_dbflags = (unsigned char *)(txn->mt_dbs + env->me_maxdbs);
	2645	txn->mt_dbiseqs = env->me_dbiseqs;
2412	2646	} else {
2413	2647	txn->mt_cursors = (MDB_cursor **)(txn->mt_dbs + env->me_maxdbs);
2414		txn->mt_dbflags = (unsigned char *)(txn->mt_cursors + env->me_maxdbs);
	2648	if (parent) {
	2649	txn->mt_dbiseqs = parent->mt_dbiseqs;
	2650	txn->mt_dbflags = (unsigned char *)(txn->mt_cursors + env->me_maxdbs);
	2651	} else {
	2652	txn->mt_dbiseqs = (unsigned int *)(txn->mt_cursors + env->me_maxdbs);
	2653	txn->mt_dbflags = (unsigned char *)(txn->mt_dbiseqs + env->me_maxdbs);
	2654	}
2415	2655	}
2416	2656	txn->mt_env = env;
2417	2657
	2658	ok:
2418	2659	if (parent) {
2419	2660	unsigned int i;
2420	2661	txn->mt_u.dirty_list = malloc(sizeof(MDB_ID2)*MDB_IDL_UM_SIZE);

2457	2698	} else {
2458	2699	rc = mdb_txn_renew0(txn);
2459	2700	}
2460		if (rc)
2461		free(txn);
2462		else {
	2701	if (rc) {
	2702	if (txn != env->me_txn0)
	2703	free(txn);
	2704	} else {
2463	2705	*ret = txn;
2464	2706	DPRINTF(("begin txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
2465	2707	txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',

2491	2733	env->me_dbflags[i] = txn->mt_dbs[i].md_flags \| MDB_VALID;
2492	2734	} else {
2493	2735	char *ptr = env->me_dbxs[i].md_name.mv_data;
2494		env->me_dbxs[i].md_name.mv_data = NULL;
2495		env->me_dbxs[i].md_name.mv_size = 0;
2496		env->me_dbflags[i] = 0;
2497		free(ptr);
	2736	if (ptr) {
	2737	env->me_dbxs[i].md_name.mv_data = NULL;
	2738	env->me_dbxs[i].md_name.mv_size = 0;
	2739	env->me_dbflags[i] = 0;
	2740	env->me_dbiseqs[i]++;
	2741	free(ptr);
	2742	}
2498	2743	}
2499	2744	}
2500	2745	}

2583	2828	if ((txn->mt_flags & MDB_TXN_RDONLY) && txn->mt_u.reader)
2584	2829	txn->mt_u.reader->mr_pid = 0;
2585	2830
2586		free(txn);
	2831	if (txn != txn->mt_env->me_txn0)
	2832	free(txn);
2587	2833	}
2588	2834
2589	2835	/** Save the freelist as of this transaction to the freeDB.

2610	2856	rc = mdb_page_search(&mc, NULL, MDB_PS_FIRST\|MDB_PS_MODIFY);
2611	2857	if (rc && rc != MDB_NOTFOUND)
2612	2858	return rc;
	2859	}
	2860
	2861	if (!env->me_pghead && txn->mt_loose_pgs) {
	2862	/* Put loose page numbers in mt_free_pgs, since
	2863	* we may be unable to return them to me_pghead.
	2864	*/
	2865	MDB_page *mp = txn->mt_loose_pgs;
	2866	if ((rc = mdb_midl_need(&txn->mt_free_pgs, txn->mt_loose_count)) != 0)
	2867	return rc;
	2868	for (; mp; mp = NEXT_LOOSE_PAGE(mp))
	2869	mdb_midl_xappend(txn->mt_free_pgs, mp->mp_pgno);
	2870	txn->mt_loose_pgs = NULL;
	2871	txn->mt_loose_count = 0;
2613	2872	}
2614	2873
2615	2874	/* MDB_RESERVE cancels meminit in ovpage malloc (when no WRITEMAP) */

2673	2932	}
2674	2933
2675	2934	mop = env->me_pghead;
2676		mop_len = mop ? mop[0] : 0;
	2935	mop_len = (mop ? mop[0] : 0) + txn->mt_loose_count;
2677	2936
2678	2937	/* Reserve records for me_pghead[]. Split it if multi-page,
2679	2938	* to avoid searching freeDB for a page range. Use keys in

2713	2972	total_room += head_room;
2714	2973	}
2715	2974
	2975	/* Return loose page numbers to me_pghead, though usually none are
	2976	* left at this point. The pages themselves remain in dirty_list.
	2977	*/
	2978	if (txn->mt_loose_pgs) {
	2979	MDB_page *mp = txn->mt_loose_pgs;
	2980	unsigned count = txn->mt_loose_count;
	2981	MDB_IDL loose;
	2982	/* Room for loose pages + temp IDL with same */
	2983	if ((rc = mdb_midl_need(&env->me_pghead, 2*count+1)) != 0)
	2984	return rc;
	2985	mop = env->me_pghead;
	2986	loose = mop + MDB_IDL_ALLOCLEN(mop) - count;
	2987	for (count = 0; mp; mp = NEXT_LOOSE_PAGE(mp))
	2988	loose[ ++count ] = mp->mp_pgno;
	2989	loose[0] = count;
	2990	mdb_midl_sort(loose);
	2991	mdb_midl_xmerge(mop, loose);
	2992	txn->mt_loose_pgs = NULL;
	2993	txn->mt_loose_count = 0;
	2994	mop_len = mop[0];
	2995	}
	2996
2716	2997	/* Fill in the reserved me_pghead records */
2717	2998	rc = MDB_SUCCESS;
2718	2999	if (mop_len) {

2721	3002	mop += mop_len;
2722	3003	rc = mdb_cursor_first(&mc, &key, &data);
2723	3004	for (; !rc; rc = mdb_cursor_next(&mc, &key, &data, MDB_NEXT)) {
2724		unsigned flags = MDB_CURRENT;
2725	3005	txnid_t id = (txnid_t )key.mv_data;
2726	3006	ssize_t len = (ssize_t)(data.mv_size / sizeof(MDB_ID)) - 1;
2727	3007	MDB_ID save;

2731	3011	if (len > mop_len) {
2732	3012	len = mop_len;
2733	3013	data.mv_size = (len + 1) * sizeof(MDB_ID);
2734		flags = 0;
2735	3014	}
2736	3015	data.mv_data = mop -= len;
2737	3016	save = mop[0];
2738	3017	mop[0] = len;
2739		rc = mdb_cursor_put(&mc, &key, &data, flags);
	3018	rc = mdb_cursor_put(&mc, &key, &data, MDB_CURRENT);
2740	3019	mop[0] = save;
2741	3020	if (rc \|\| !(mop_len -= len))
2742	3021	break;

2776	3055	while (++i <= pagecount) {
2777	3056	dp = dl[i].mptr;
2778	3057	/* Don't flush this page yet */
2779		if (dp->mp_flags & P_KEEP) {
2780		dp->mp_flags ^= P_KEEP;
	3058	if (dp->mp_flags & (P_LOOSE\|P_KEEP)) {
	3059	dp->mp_flags &= ~P_KEEP;
2781	3060	dl[++j] = dl[i];
2782	3061	continue;
2783	3062	}

2791	3070	if (++i <= pagecount) {
2792	3071	dp = dl[i].mptr;
2793	3072	/* Don't flush this page yet */
2794		if (dp->mp_flags & P_KEEP) {
2795		dp->mp_flags ^= P_KEEP;
	3073	if (dp->mp_flags & (P_LOOSE\|P_KEEP)) {
	3074	dp->mp_flags &= ~P_KEEP;
2796	3075	dl[i].mid = 0;
2797	3076	continue;
2798	3077	}

2867	3146	#endif /* _WIN32 */
2868	3147	}
2869	3148
	3149	/* MIPS has cache coherency issues, this is a no-op everywhere else
	3150	* Note: for any size >= on-chip cache size, entire on-chip cache is
	3151	* flushed.
	3152	*/
	3153	CACHEFLUSH(env->me_map, txn->mt_next_pgno * env->me_psize, DCACHE);
	3154
2870	3155	for (i = keep; ++i <= pagecount; ) {
2871	3156	dp = dl[i].mptr;
2872	3157	/* This is a page we skipped above */

2921	3206
2922	3207	if (txn->mt_parent) {
2923	3208	MDB_txn *parent = txn->mt_parent;
	3209	MDB_page **lp;
2924	3210	MDB_ID2L dst, src;
2925	3211	MDB_IDL pspill;
2926	3212	unsigned x, y, len, ps_len;

3018	3304	}
3019	3305	}
3020	3306
	3307	/* Append our loose page list to parent's */
	3308	for (lp = &parent->mt_loose_pgs; *lp; lp = &NEXT_LOOSE_PAGE(lp))
	3309	;
	3310	*lp = txn->mt_loose_pgs;
	3311	parent->mt_loose_count += txn->mt_loose_count;
	3312
3021	3313	parent->mt_child = NULL;
3022	3314	mdb_midl_free(((MDB_ntxn *)txn)->mnt_pgstate.mf_pghead);
3023	3315	free(txn);

3049	3341	mdb_cursor_init(&mc, txn, MAIN_DBI, NULL);
3050	3342	for (i = 2; i < txn->mt_numdbs; i++) {
3051	3343	if (txn->mt_dbflags[i] & DB_DIRTY) {
	3344	if (TXN_DBI_CHANGED(txn, i)) {
	3345	rc = MDB_BAD_DBI;
	3346	goto fail;
	3347	}
3052	3348	data.mv_data = &txn->mt_dbs[i];
3053	3349	rc = mdb_cursor_put(&mc, &txn->mt_dbxs[i].md_name, &data, 0);
3054	3350	if (rc)

3075	3371	(rc = mdb_env_write_meta(txn)))
3076	3372	goto fail;
3077	3373
	3374	/* Free P_LOOSE pages left behind in dirty_list */
	3375	if (!(env->me_flags & MDB_WRITEMAP))
	3376	mdb_dlist_free(txn);
	3377
3078	3378	done:
3079	3379	env->me_pglast = 0;
3080	3380	env->me_txn = NULL;

3082	3382
3083	3383	if (env->me_txns)
3084	3384	UNLOCK_MUTEX_W(env);
3085		free(txn);
	3385	if (txn != env->me_txn0)
	3386	free(txn);
3086	3387
3087	3388	return MDB_SUCCESS;
3088	3389

3097	3398	* @param[out] meta address of where to store the meta information
3098	3399	* @return 0 on success, non-zero on failure.
3099	3400	*/
3100		static int
	3401	static int ESECT
3101	3402	mdb_env_read_header(MDB_env env, MDB_meta meta)
3102	3403	{
3103	3404	MDB_metabuf pbuf;

3155	3456	return 0;
3156	3457	}
3157	3458
	3459	static void ESECT
	3460	mdb_env_init_meta0(MDB_env env, MDB_meta meta)
	3461	{
	3462	meta->mm_magic = MDB_MAGIC;
	3463	meta->mm_version = MDB_DATA_VERSION;
	3464	meta->mm_mapsize = env->me_mapsize;
	3465	meta->mm_psize = env->me_psize;
	3466	meta->mm_last_pg = 1;
	3467	meta->mm_flags = env->me_flags & 0xffff;
	3468	meta->mm_flags \|= MDB_INTEGERKEY;
	3469	meta->mm_dbs[0].md_root = P_INVALID;
	3470	meta->mm_dbs[1].md_root = P_INVALID;
	3471	}
	3472
3158	3473	/** Write the environment parameters of a freshly created DB environment.
3159	3474	* @param[in] env the environment handle
3160	3475	* @param[out] meta address of where to store the meta information
3161	3476	* @return 0 on success, non-zero on failure.
3162	3477	*/
3163		static int
	3478	static int ESECT
3164	3479	mdb_env_init_meta(MDB_env env, MDB_meta meta)
3165	3480	{
3166	3481	MDB_page p, q;

3184	3499
3185	3500	psize = env->me_psize;
3186	3501
3187		meta->mm_magic = MDB_MAGIC;
3188		meta->mm_version = MDB_DATA_VERSION;
3189		meta->mm_mapsize = env->me_mapsize;
3190		meta->mm_psize = psize;
3191		meta->mm_last_pg = 1;
3192		meta->mm_flags = env->me_flags & 0xffff;
3193		meta->mm_flags \|= MDB_INTEGERKEY;
3194		meta->mm_dbs[0].md_root = P_INVALID;
3195		meta->mm_dbs[1].md_root = P_INVALID;
	3502	mdb_env_init_meta0(env, meta);
3196	3503
3197	3504	p = calloc(2, psize);
3198	3505	p->mp_pgno = 0;

3224	3531	{
3225	3532	MDB_env *env;
3226	3533	MDB_meta meta, metab, *mp;
	3534	size_t mapsize;
3227	3535	off_t off;
3228	3536	int rc, len, toggle;
3229	3537	char *ptr;

3240	3548
3241	3549	env = txn->mt_env;
3242	3550	mp = env->me_metas[toggle];
	3551	mapsize = env->me_metas[toggle ^ 1]->mm_mapsize;
	3552	/* Persist any increases of mapsize config */
	3553	if (mapsize < env->me_mapsize)
	3554	mapsize = env->me_mapsize;
3243	3555
3244	3556	if (env->me_flags & MDB_WRITEMAP) {
3245		/* Persist any increases of mapsize config */
3246		if (env->me_mapsize > mp->mm_mapsize)
3247		mp->mm_mapsize = env->me_mapsize;
	3557	mp->mm_mapsize = mapsize;
3248	3558	mp->mm_dbs[0] = txn->mt_dbs[0];
3249	3559	mp->mm_dbs[1] = txn->mt_dbs[1];
3250	3560	mp->mm_last_pg = txn->mt_next_pgno - 1;

3271	3581	metab.mm_txnid = env->me_metas[toggle]->mm_txnid;
3272	3582	metab.mm_last_pg = env->me_metas[toggle]->mm_last_pg;
3273	3583
3274		ptr = (char *)&meta;
3275		if (env->me_mapsize > mp->mm_mapsize) {
3276		/* Persist any increases of mapsize config */
3277		meta.mm_mapsize = env->me_mapsize;
3278		off = offsetof(MDB_meta, mm_mapsize);
3279		} else {
3280		off = offsetof(MDB_meta, mm_dbs[0].md_depth);
3281		}
3282		len = sizeof(MDB_meta) - off;
3283
3284		ptr += off;
	3584	meta.mm_mapsize = mapsize;
3285	3585	meta.mm_dbs[0] = txn->mt_dbs[0];
3286	3586	meta.mm_dbs[1] = txn->mt_dbs[1];
3287	3587	meta.mm_last_pg = txn->mt_next_pgno - 1;
3288	3588	meta.mm_txnid = txn->mt_txnid;
3289	3589
	3590	off = offsetof(MDB_meta, mm_mapsize);
	3591	ptr = (char *)&meta + off;
	3592	len = sizeof(MDB_meta) - off;
3290	3593	if (toggle)
3291	3594	off += env->me_psize;
3292	3595	off += PAGEHDRSZ;

3325	3628	env->me_flags \|= MDB_FATAL_ERROR;
3326	3629	return rc;
3327	3630	}
	3631	/* MIPS has cache coherency issues, this is a no-op everywhere else */
	3632	CACHEFLUSH(env->me_map + off, len, DCACHE);
3328	3633	done:
3329	3634	/* Memory ordering issues are irrelevant; since the entire writer
3330	3635	* is wrapped by wmutex, all of these changes will become visible

3348	3653	return (env->me_metas[0]->mm_txnid < env->me_metas[1]->mm_txnid);
3349	3654	}
3350	3655
3351		int
	3656	int ESECT
3352	3657	mdb_env_create(MDB_env **env)
3353	3658	{
3354	3659	MDB_env *e;

3373	3678	return MDB_SUCCESS;
3374	3679	}
3375	3680
3376		static int
3377		mdb_env_map(MDB_env env, void addr, int newsize)
	3681	static int ESECT
	3682	mdb_env_map(MDB_env env, void addr)
3378	3683	{
3379	3684	MDB_page *p;
3380	3685	unsigned int flags = env->me_flags;

3382	3687	int rc;
3383	3688	HANDLE mh;
3384	3689	LONG sizelo, sizehi;
3385		sizelo = env->me_mapsize & 0xffffffff;
3386		sizehi = env->me_mapsize >> 16 >> 16; /* only needed on Win64 */
3387
3388		/* Windows won't create mappings for zero length files.
3389		* Just allocate the maxsize right now.
3390		*/
3391		if (newsize) {
	3690	size_t msize;
	3691
	3692	if (flags & MDB_RDONLY) {
	3693	/* Don't set explicit map size, use whatever exists */
	3694	msize = 0;
	3695	sizelo = 0;
	3696	sizehi = 0;
	3697	} else {
	3698	msize = env->me_mapsize;
	3699	sizelo = msize & 0xffffffff;
	3700	sizehi = msize >> 16 >> 16; /* only needed on Win64 */
	3701
	3702	/* Windows won't create mappings for zero length files.
	3703	* and won't map more than the file size.
	3704	* Just set the maxsize right now.
	3705	*/
3392	3706	if (SetFilePointer(env->me_fd, sizelo, &sizehi, 0) != (DWORD)sizelo
3393	3707	\|\| !SetEndOfFile(env->me_fd)
3394	3708	\|\| SetFilePointer(env->me_fd, 0, NULL, 0) != 0)
3395	3709	return ErrCode();
3396	3710	}
	3711
3397	3712	mh = CreateFileMapping(env->me_fd, NULL, flags & MDB_WRITEMAP ?
3398	3713	PAGE_READWRITE : PAGE_READONLY,
3399	3714	sizehi, sizelo, NULL);

3401	3716	return ErrCode();
3402	3717	env->me_map = MapViewOfFileEx(mh, flags & MDB_WRITEMAP ?
3403	3718	FILE_MAP_WRITE : FILE_MAP_READ,
3404		0, 0, env->me_mapsize, addr);
	3719	0, 0, msize, addr);
3405	3720	rc = env->me_map ? 0 : ErrCode();
3406	3721	CloseHandle(mh);
3407	3722	if (rc)

3447	3762	return MDB_SUCCESS;
3448	3763	}
3449	3764
3450		int
	3765	int ESECT
3451	3766	mdb_env_set_mapsize(MDB_env *env, size_t size)
3452	3767	{
3453	3768	/* If env is already open, caller is responsible for making

3471	3786	munmap(env->me_map, env->me_mapsize);
3472	3787	env->me_mapsize = size;
3473	3788	old = (env->me_flags & MDB_FIXEDMAP) ? env->me_map : NULL;
3474		rc = mdb_env_map(env, old, 1);
	3789	rc = mdb_env_map(env, old);
3475	3790	if (rc)
3476	3791	return rc;
3477	3792	}

3481	3796	return MDB_SUCCESS;
3482	3797	}
3483	3798
3484		int
	3799	int ESECT
3485	3800	mdb_env_set_maxdbs(MDB_env *env, MDB_dbi dbs)
3486	3801	{
3487	3802	if (env->me_map)

3490	3805	return MDB_SUCCESS;
3491	3806	}
3492	3807
3493		int
	3808	int ESECT
3494	3809	mdb_env_set_maxreaders(MDB_env *env, unsigned int readers)
3495	3810	{
3496	3811	if (env->me_map \|\| readers < 1)

3499	3814	return MDB_SUCCESS;
3500	3815	}
3501	3816
3502		int
	3817	int ESECT
3503	3818	mdb_env_get_maxreaders(MDB_env env, unsigned int readers)
3504	3819	{
3505	3820	if (!env \|\| !readers)

3508	3823	return MDB_SUCCESS;
3509	3824	}
3510	3825
3511		/** Further setup required for opening an MDB environment
	3826	/** Further setup required for opening an LMDB environment
3512	3827	*/
3513		static int
	3828	static int ESECT
3514	3829	mdb_env_open2(MDB_env *env)
3515	3830	{
3516	3831	unsigned int flags = env->me_flags;

3555	3870	env->me_mapsize = minsize;
3556	3871	}
3557	3872
3558		rc = mdb_env_map(env, meta.mm_address, newenv \|\| env->me_mapsize != meta.mm_mapsize);
	3873	rc = mdb_env_map(env, (flags & MDB_FIXEDMAP) ? meta.mm_address : NULL);
3559	3874	if (rc)
3560	3875	return rc;
3561	3876

3630	3945	case DLL_THREAD_DETACH:
3631	3946	for (i=0; i<mdb_tls_nkeys; i++) {
3632	3947	MDB_reader *r = pthread_getspecific(mdb_tls_keys[i]);
3633		mdb_env_reader_dest(r);
	3948	if (r) {
	3949	mdb_env_reader_dest(r);
	3950	}
3634	3951	}
3635	3952	break;
3636	3953	case DLL_PROCESS_DETACH: break;

3665	3982	#endif
3666	3983
3667	3984	/** Downgrade the exclusive lock on the region back to shared */
3668		static int
	3985	static int ESECT
3669	3986	mdb_env_share_locks(MDB_env env, int excl)
3670	3987	{
3671	3988	int rc = 0, toggle = mdb_env_pick_meta(env);

3707	4024	/** Try to get exlusive lock, otherwise shared.
3708	4025	* Maintain *excl = -1: no/unknown lock, 0: shared, 1: exclusive.
3709	4026	*/
3710		static int
	4027	static int ESECT
3711	4028	mdb_env_excl_lock(MDB_env env, int excl)
3712	4029	{
3713	4030	int rc = 0;

3842	4159	#endif
3843	4160
3844	4161	/** Open and/or initialize the lock region for the environment.
3845		* @param[in] env The MDB environment.
	4162	* @param[in] env The LMDB environment.
3846	4163	* @param[in] lpath The pathname of the file used for the lock region.
3847	4164	* @param[in] mode The Unix permissions for the file, if we create it.
3848	4165	* @param[out] excl Resulting file lock type: -1 none, 0 shared, 1 exclusive
3849	4166	* @param[in,out] excl In -1, out lock type: -1 none, 0 shared, 1 exclusive
3850	4167	* @return 0 on success, non-zero on failure.
3851	4168	*/
3852		static int
	4169	static int ESECT
3853	4170	mdb_env_setup_locks(MDB_env env, char lpath, int mode, int *excl)
3854	4171	{
3855	4172	#ifdef _WIN32

4079	4396	# error "Persistent DB flags & env flags overlap, but both go in mm_flags"
4080	4397	#endif
4081	4398
4082		int
	4399	int ESECT
4083	4400	mdb_env_open(MDB_env env, const char path, unsigned int flags, mdb_mode_t mode)
4084	4401	{
4085	4402	int oflags, rc, len, excl = -1;

4124	4441	env->me_path = strdup(path);
4125	4442	env->me_dbxs = calloc(env->me_maxdbs, sizeof(MDB_dbx));
4126	4443	env->me_dbflags = calloc(env->me_maxdbs, sizeof(uint16_t));
4127		if (!(env->me_dbxs && env->me_path && env->me_dbflags)) {
	4444	env->me_dbiseqs = calloc(env->me_maxdbs, sizeof(unsigned int));
	4445	if (!(env->me_dbxs && env->me_path && env->me_dbflags && env->me_dbiseqs)) {
4128	4446	rc = ENOMEM;
4129	4447	goto leave;
4130	4448	}

4196	4514	if (!((flags & MDB_RDONLY) \|\|
4197	4515	(env->me_pbuf = calloc(1, env->me_psize))))
4198	4516	rc = ENOMEM;
	4517	if (!(flags & MDB_RDONLY)) {
	4518	MDB_txn *txn;
	4519	int tsize = sizeof(MDB_txn), size = tsize + env->me_maxdbs *
	4520	(sizeof(MDB_db)+sizeof(MDB_cursor)+sizeof(unsigned int)+1);
	4521	txn = calloc(1, size);
	4522	if (txn) {
	4523	txn->mt_dbs = (MDB_db )((char )txn + tsize);
	4524	txn->mt_cursors = (MDB_cursor **)(txn->mt_dbs + env->me_maxdbs);
	4525	txn->mt_dbiseqs = (unsigned int *)(txn->mt_cursors + env->me_maxdbs);
	4526	txn->mt_dbflags = (unsigned char *)(txn->mt_dbiseqs + env->me_maxdbs);
	4527	txn->mt_env = env;
	4528	env->me_txn0 = txn;
	4529	} else {
	4530	rc = ENOMEM;
	4531	}
	4532	}
4199	4533	}
4200	4534
4201	4535	leave:

4207	4541	}
4208	4542
4209	4543	/** Destroy resources from mdb_env_open(), clear our readers & DBIs */
4210		static void
	4544	static void ESECT
4211	4545	mdb_env_close0(MDB_env *env, int excl)
4212	4546	{
4213	4547	int i;

4220	4554	free(env->me_dbxs[i].md_name.mv_data);
4221	4555
4222	4556	free(env->me_pbuf);
	4557	free(env->me_dbiseqs);
4223	4558	free(env->me_dbflags);
4224	4559	free(env->me_dbxs);
4225	4560	free(env->me_path);
4226	4561	free(env->me_dirty_list);
	4562	free(env->me_txn0);
4227	4563	mdb_midl_free(env->me_free_pgs);
4228	4564
4229	4565	if (env->me_flags & MDB_ENV_TXKEY) {

4295	4631	env->me_flags &= ~(MDB_ENV_ACTIVE\|MDB_ENV_TXKEY);
4296	4632	}
4297	4633
4298		int
4299		mdb_env_copyfd(MDB_env *env, HANDLE fd)
4300		{
4301		MDB_txn *txn = NULL;
4302		int rc;
4303		size_t wsize;
4304		char *ptr;
4305		#ifdef _WIN32
4306		DWORD len, w2;
4307		#define DO_WRITE(rc, fd, ptr, w2, len) rc = WriteFile(fd, ptr, w2, &len, NULL)
4308		#else
4309		ssize_t len;
4310		size_t w2;
4311		#define DO_WRITE(rc, fd, ptr, w2, len) len = write(fd, ptr, w2); rc = (len >= 0)
4312		#endif
4313
4314		/* Do the lock/unlock of the reader mutex before starting the
4315		* write txn. Otherwise other read txns could block writers.
4316		*/
4317		rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
4318		if (rc)
4319		return rc;
4320
4321		if (env->me_txns) {
4322		/* We must start the actual read txn after blocking writers */
4323		mdb_txn_reset0(txn, "reset-stage1");
4324
4325		/* Temporarily block writers until we snapshot the meta pages */
4326		LOCK_MUTEX_W(env);
4327
4328		rc = mdb_txn_renew0(txn);
4329		if (rc) {
4330		UNLOCK_MUTEX_W(env);
4331		goto leave;
4332		}
4333		}
4334
4335		wsize = env->me_psize * 2;
4336		ptr = env->me_map;
4337		w2 = wsize;
4338		while (w2 > 0) {
4339		DO_WRITE(rc, fd, ptr, w2, len);
4340		if (!rc) {
4341		rc = ErrCode();
4342		break;
4343		} else if (len > 0) {
4344		rc = MDB_SUCCESS;
4345		ptr += len;
4346		w2 -= len;
4347		continue;
4348		} else {
4349		/* Non-blocking or async handles are not supported */
4350		rc = EIO;
4351		break;
4352		}
4353		}
4354		if (env->me_txns)
4355		UNLOCK_MUTEX_W(env);
4356
4357		if (rc)
4358		goto leave;
4359
4360		wsize = txn->mt_next_pgno * env->me_psize - wsize;
4361		while (wsize > 0) {
4362		if (wsize > MAX_WRITE)
4363		w2 = MAX_WRITE;
4364		else
4365		w2 = wsize;
4366		DO_WRITE(rc, fd, ptr, w2, len);
4367		if (!rc) {
4368		rc = ErrCode();
4369		break;
4370		} else if (len > 0) {
4371		rc = MDB_SUCCESS;
4372		ptr += len;
4373		wsize -= len;
4374		continue;
4375		} else {
4376		rc = EIO;
4377		break;
4378		}
4379		}
4380
4381		leave:
4382		mdb_txn_abort(txn);
4383		return rc;
4384		}
4385
4386		int
4387		mdb_env_copy(MDB_env env, const char path)
4388		{
4389		int rc, len;
4390		char *lpath;
4391		HANDLE newfd = INVALID_HANDLE_VALUE;
4392
4393		if (env->me_flags & MDB_NOSUBDIR) {
4394		lpath = (char *)path;
4395		} else {
4396		len = strlen(path);
4397		len += sizeof(DATANAME);
4398		lpath = malloc(len);
4399		if (!lpath)
4400		return ENOMEM;
4401		sprintf(lpath, "%s" DATANAME, path);
4402		}
4403
4404		/* The destination path must exist, but the destination file must not.
4405		* We don't want the OS to cache the writes, since the source data is
4406		* already in the OS cache.
4407		*/
4408		#ifdef _WIN32
4409		newfd = CreateFile(lpath, GENERIC_WRITE, 0, NULL, CREATE_NEW,
4410		FILE_FLAG_NO_BUFFERING\|FILE_FLAG_WRITE_THROUGH, NULL);
4411		#else
4412		newfd = open(lpath, O_WRONLY\|O_CREAT\|O_EXCL, 0666);
4413		#endif
4414		if (newfd == INVALID_HANDLE_VALUE) {
4415		rc = ErrCode();
4416		goto leave;
4417		}
4418
4419		#ifdef O_DIRECT
4420		/* Set O_DIRECT if the file system supports it */
4421		if ((rc = fcntl(newfd, F_GETFL)) != -1)
4422		(void) fcntl(newfd, F_SETFL, rc \| O_DIRECT);
4423		#endif
4424		#ifdef F_NOCACHE /* __APPLE__ */
4425		rc = fcntl(newfd, F_NOCACHE, 1);
4426		if (rc) {
4427		rc = ErrCode();
4428		goto leave;
4429		}
4430		#endif
4431
4432		rc = mdb_env_copyfd(env, newfd);
4433
4434		leave:
4435		if (!(env->me_flags & MDB_NOSUBDIR))
4436		free(lpath);
4437		if (newfd != INVALID_HANDLE_VALUE)
4438		if (close(newfd) < 0 && rc == MDB_SUCCESS)
4439		rc = ErrCode();
4440
4441		return rc;
4442		}
4443
4444		void
	4634
	4635	void ESECT
4445	4636	mdb_env_close(MDB_env *env)
4446	4637	{
4447	4638	MDB_page *dp;

4493	4684	} while(!x && u > (unsigned short *)a->mv_data);
4494	4685	return x;
4495	4686	#else
4496		return memcmp(a->mv_data, b->mv_data, a->mv_size);
4497		#endif
4498		}
	4687	unsigned short u, c, *end;
	4688	int x;
	4689
	4690	end = (unsigned short ) ((char ) a->mv_data + a->mv_size);
	4691	u = (unsigned short *)a->mv_data;
	4692	c = (unsigned short *)b->mv_data;
	4693	do {
	4694	x = u++ - c++;
	4695	} while(!x && u < end);
	4696	return x;
	4697	#endif
	4698	}
	4699
	4700	/** Compare two items pointing at size_t's of unknown alignment. */
	4701	#ifdef MISALIGNED_OK
	4702	# define mdb_cmp_clong mdb_cmp_long
	4703	#else
	4704	# define mdb_cmp_clong mdb_cmp_cint
	4705	#endif
4499	4706
4500	4707	/** Compare two items lexically */
4501	4708	static int

4868	5075	/* Make sure we're using an up-to-date root */
4869	5076	if (*mc->mc_dbflag & DB_STALE) {
4870	5077	MDB_cursor mc2;
	5078	if (TXN_DBI_CHANGED(mc->mc_txn, mc->mc_dbi))
	5079	return MDB_BAD_DBI;
4871	5080	mdb_cursor_init(&mc2, mc->mc_txn, MAIN_DBI, NULL);
4872	5081	rc = mdb_page_search(&mc2, &mc->mc_dbx->md_name, 0);
4873	5082	if (rc)

5040	5249	int exact = 0;
5041	5250	DKBUF;
5042	5251
5043		if (key == NULL \|\| data == NULL)
5044		return EINVAL;
5045
5046	5252	DPRINTF(("===> get db %u key [%s]", dbi, DKEY(key)));
5047	5253
5048		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	5254	if (!key \|\| !data \|\| dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
5049	5255	return EINVAL;
5050	5256
5051	5257	if (txn->mt_flags & MDB_TXN_ERROR)

5211	5417	if (op == MDB_PREV \|\| op == MDB_PREV_DUP) {
5212	5418	rc = mdb_cursor_prev(&mc->mc_xcursor->mx_cursor, data, NULL, MDB_PREV);
5213	5419	if (op != MDB_PREV \|\| rc != MDB_NOTFOUND) {
5214		if (rc == MDB_SUCCESS)
	5420	if (rc == MDB_SUCCESS) {
5215	5421	MDB_GET_KEY(leaf, key);
	5422	mc->mc_flags &= ~C_EOF;
	5423	}
5216	5424	return rc;
5217	5425	}
5218	5426	} else {

5368	5576	if (!mc->mc_top) {
5369	5577	/* There are no other pages */
5370	5578	mc->mc_ki[mc->mc_top] = 0;
5371		if (op == MDB_SET_RANGE) {
	5579	if (op == MDB_SET_RANGE && !exactp) {
5372	5580	rc = 0;
5373	5581	goto set1;
5374	5582	} else

5404	5612	mc->mc_flags &= ~C_EOF;
5405	5613
5406	5614	if (IS_LEAF2(mp)) {
5407		key->mv_size = mc->mc_db->md_pad;
5408		key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
	5615	if (op == MDB_SET_RANGE \|\| op == MDB_SET_KEY) {
	5616	key->mv_size = mc->mc_db->md_pad;
	5617	key->mv_data = LEAF2KEY(mp, mc->mc_ki[mc->mc_top], key->mv_size);
	5618	}
5409	5619	return MDB_SUCCESS;
5410	5620	}
5411	5621

5687	5897	rc = MDB_INCOMPATIBLE;
5688	5898	break;
5689	5899	}
	5900	{
	5901	MDB_node *leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
	5902	if (!F_ISSET(leaf->mn_flags, F_DUPDATA)) {
	5903	MDB_GET_KEY(leaf, key);
	5904	rc = mdb_node_read(mc->mc_txn, leaf, data);
	5905	break;
	5906	}
	5907	}
5690	5908	if (!(mc->mc_xcursor->mx_cursor.mc_flags & C_INITIALIZED)) {
5691	5909	rc = EINVAL;
5692	5910	break;

5723	5941	if (mc->mc_dbi > MAIN_DBI && !(*mc->mc_dbflag & DB_DIRTY)) {
5724	5942	MDB_cursor mc2;
5725	5943	MDB_xcursor mcx;
	5944	if (TXN_DBI_CHANGED(mc->mc_txn, mc->mc_dbi))
	5945	return MDB_BAD_DBI;
5726	5946	mdb_cursor_init(&mc2, mc->mc_txn, MAIN_DBI, &mcx);
5727	5947	rc = mdb_page_search(&mc2, &mc->mc_dbx->md_name, MDB_PS_MODIFY);
5728	5948	if (rc)

5753	5973	uint16_t fp_flags;
5754	5974	MDB_val xdata, *rdata, dkey, olddata;
5755	5975	MDB_db dummy;
5756		int do_sub = 0, insert;
	5976	int do_sub = 0, insert_key, insert_data;
5757	5977	unsigned int mcount = 0, dcount = 0, nospill;
5758	5978	size_t nsize;
5759	5979	int rc, rc2;

5781	6001	if (mc->mc_txn->mt_flags & (MDB_TXN_RDONLY\|MDB_TXN_ERROR))
5782	6002	return (mc->mc_txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
5783	6003
5784		if (flags != MDB_CURRENT && key->mv_size-1 >= ENV_MAXKEY(env))
	6004	if (key->mv_size-1 >= ENV_MAXKEY(env))
5785	6005	return MDB_BAD_VALSIZE;
5786	6006
5787	6007	#if SIZE_MAX > MAXDATASIZE

5872	6092	return rc2;
5873	6093	}
5874	6094
5875		insert = rc;
5876		if (insert) {
	6095	insert_key = insert_data = rc;
	6096	if (insert_key) {
5877	6097	/* The key does not exist */
5878	6098	DPRINTF(("inserting key at index %i", mc->mc_ki[mc->mc_top]));
5879	6099	if ((mc->mc_db->md_flags & MDB_DUPSORT) &&
5880	6100	LEAFSIZE(key, data) > env->me_nodemax)
5881	6101	{
5882		/* Too big for a node, insert in sub-DB */
	6102	/* Too big for a node, insert in sub-DB. Set up an empty
	6103	* "old sub-page" for prep_subDB to expand to a full page.
	6104	*/
5883	6105	fp_flags = P_LEAF\|P_DIRTY;
5884	6106	fp = env->me_pbuf;
5885	6107	fp->mp_pad = data->mv_size; /* used if MDB_DUPFIXED */
5886		fp->mp_lower = fp->mp_upper = olddata.mv_size = PAGEHDRSZ;
	6108	fp->mp_lower = fp->mp_upper = (PAGEHDRSZ-PAGEBASE);
	6109	olddata.mv_size = PAGEHDRSZ;
5887	6110	goto prep_subDB;
5888	6111	}
5889	6112	} else {
5890	6113	/* there's only a key anyway, so this is a no-op */
5891	6114	if (IS_LEAF2(mc->mc_pg[mc->mc_top])) {
	6115	char *ptr;
5892	6116	unsigned int ksize = mc->mc_db->md_pad;
5893	6117	if (key->mv_size != ksize)
5894	6118	return MDB_BAD_VALSIZE;
5895		if (flags == MDB_CURRENT) {
5896		char *ptr = LEAF2KEY(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top], ksize);
5897		memcpy(ptr, key->mv_data, ksize);
	6119	ptr = LEAF2KEY(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top], ksize);
	6120	memcpy(ptr, key->mv_data, ksize);
	6121	fix_parent:
	6122	/* if overwriting slot 0 of leaf, need to
	6123	* update branch key if there is a parent page
	6124	*/
	6125	if (mc->mc_top && !mc->mc_ki[mc->mc_top]) {
	6126	unsigned short top = mc->mc_top;
	6127	mc->mc_top--;
	6128	/* slot 0 is always an empty key, find real slot */
	6129	while (mc->mc_top && !mc->mc_ki[mc->mc_top])
	6130	mc->mc_top--;
	6131	if (mc->mc_ki[mc->mc_top])
	6132	rc2 = mdb_update_key(mc, key);
	6133	else
	6134	rc2 = MDB_SUCCESS;
	6135	mc->mc_top = top;
	6136	if (rc2)
	6137	return rc2;
5898	6138	}
5899	6139	return MDB_SUCCESS;
5900	6140	}

5923	6163
5924	6164	#if UINT_MAX < SIZE_MAX
5925	6165	if (mc->mc_dbx->md_dcmp == mdb_cmp_int && olddata.mv_size == sizeof(size_t))
5926		#ifdef MISALIGNED_OK
5927		mc->mc_dbx->md_dcmp = mdb_cmp_long;
5928		#else
5929		mc->mc_dbx->md_dcmp = mdb_cmp_cint;
5930		#endif
5931		#endif
5932		/* if data matches, skip it */
	6166	mc->mc_dbx->md_dcmp = mdb_cmp_clong;
	6167	#endif
	6168	/* does data match? */
5933	6169	if (!mc->mc_dbx->md_dcmp(data, &olddata)) {
5934	6170	if (flags & MDB_NODUPDATA)
5935		rc = MDB_KEYEXIST;
5936		else if (flags & MDB_MULTIPLE)
5937		goto next_mult;
5938		else
5939		rc = MDB_SUCCESS;
5940		return rc;
	6171	return MDB_KEYEXIST;
	6172	/* overwrite it */
	6173	goto current;
5941	6174	}
5942	6175
5943	6176	/* Back up original data item */

5946	6179
5947	6180	/* Make sub-page header for the dup items, with dummy body */
5948	6181	fp->mp_flags = P_LEAF\|P_DIRTY\|P_SUBP;
5949		fp->mp_lower = PAGEHDRSZ;
	6182	fp->mp_lower = (PAGEHDRSZ-PAGEBASE);
5950	6183	xdata.mv_size = PAGEHDRSZ + dkey.mv_size + data->mv_size;
5951	6184	if (mc->mc_db->md_flags & MDB_DUPFIXED) {
5952	6185	fp->mp_flags \|= P_LEAF2;

5956	6189	xdata.mv_size += 2 * (sizeof(indx_t) + NODESIZE) +
5957	6190	(dkey.mv_size & 1) + (data->mv_size & 1);
5958	6191	}
5959		fp->mp_upper = xdata.mv_size;
5960		olddata.mv_size = fp->mp_upper; /* pretend olddata is fp */
	6192	fp->mp_upper = xdata.mv_size - PAGEBASE;
	6193	olddata.mv_size = xdata.mv_size; /* pretend olddata is fp */
5961	6194	} else if (leaf->mn_flags & F_SUBDATA) {
5962	6195	/* Data is on sub-DB, just store it */
5963	6196	flags \|= F_DUPDATA\|F_SUBDATA;

6024	6257	if (fp_flags & P_LEAF2) {
6025	6258	memcpy(METADATA(mp), METADATA(fp), NUMKEYS(fp) * fp->mp_pad);
6026	6259	} else {
6027		memcpy((char )mp + mp->mp_upper, (char )fp + fp->mp_upper,
6028		olddata.mv_size - fp->mp_upper);
	6260	memcpy((char )mp + mp->mp_upper + PAGEBASE, (char )fp + fp->mp_upper + PAGEBASE,
	6261	olddata.mv_size - fp->mp_upper - PAGEBASE);
6029	6262	for (i=0; i<NUMKEYS(fp); i++)
6030	6263	mp->mp_ptrs[i] = fp->mp_ptrs[i] + offset;
6031	6264	}

6034	6267	rdata = &xdata;
6035	6268	flags \|= F_DUPDATA;
6036	6269	do_sub = 1;
6037		if (!insert)
	6270	if (!insert_key)
6038	6271	mdb_node_del(mc, 0);
6039	6272	goto new_sub;
6040	6273	}

6075	6308	return ENOMEM;
6076	6309	id2.mid = pg;
6077	6310	id2.mptr = np;
6078		rc = mdb_mid2l_insert(mc->mc_txn->mt_u.dirty_list, &id2);
6079		mdb_cassert(mc, rc == 0);
	6311	rc2 = mdb_mid2l_insert(mc->mc_txn->mt_u.dirty_list, &id2);
	6312	mdb_cassert(mc, rc2 == 0);
6080	6313	if (!(flags & MDB_RESERVE)) {
6081	6314	/* Copy end of page, adjusting alignment so
6082	6315	* compiler may copy words instead of bytes.

6094	6327	data->mv_data = METADATA(omp);
6095	6328	else
6096	6329	memcpy(METADATA(omp), data->mv_data, data->mv_size);
6097		goto done;
	6330	return MDB_SUCCESS;
6098	6331	}
6099	6332	}
6100	6333	if ((rc2 = mdb_ovpage_free(mc, omp)) != MDB_SUCCESS)

6106	6339	*/
6107	6340	if (F_ISSET(flags, MDB_RESERVE))
6108	6341	data->mv_data = olddata.mv_data;
6109		else if (data->mv_size)
	6342	else if (!(mc->mc_flags & C_SUB))
6110	6343	memcpy(olddata.mv_data, data->mv_data, data->mv_size);
6111		else
	6344	else {
6112	6345	memcpy(NODEKEY(leaf), key->mv_data, key->mv_size);
6113		goto done;
	6346	goto fix_parent;
	6347	}
	6348	return MDB_SUCCESS;
6114	6349	}
6115	6350	mdb_node_del(mc, 0);
6116		mc->mc_db->md_entries--;
6117	6351	}
6118	6352
6119	6353	rdata = data;

6123	6357	nsize = IS_LEAF2(mc->mc_pg[mc->mc_top]) ? key->mv_size : mdb_leaf_size(env, key, rdata);
6124	6358	if (SIZELEFT(mc->mc_pg[mc->mc_top]) < nsize) {
6125	6359	if (( flags & (F_DUPDATA\|F_SUBDATA)) == F_DUPDATA )
6126		nflags &= ~MDB_APPEND;
6127		if (!insert)
	6360	nflags &= ~MDB_APPEND; /* sub-page may need room to grow */
	6361	if (!insert_key)
6128	6362	nflags \|= MDB_SPLIT_REPLACE;
6129	6363	rc = mdb_page_split(mc, key, rdata, P_INVALID, nflags);
6130	6364	} else {
6131	6365	/* There is room already in this leaf page. */
6132	6366	rc = mdb_node_add(mc, mc->mc_ki[mc->mc_top], key, rdata, 0, nflags);
6133		if (rc == 0 && !do_sub && insert) {
	6367	if (rc == 0 && insert_key) {
6134	6368	/* Adjust other cursors pointing to mp */
6135	6369	MDB_cursor m2, m3;
6136	6370	MDB_dbi dbi = mc->mc_dbi;

6150	6384	}
6151	6385	}
6152	6386
6153		if (rc != MDB_SUCCESS)
6154		mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
6155		else {
	6387	if (rc == MDB_SUCCESS) {
6156	6388	/* Now store the actual data in the child DB. Note that we're
6157	6389	* storing the user data in the keys field, so there are strict
6158	6390	* size limits on dupdata. The actual data fields of the child

6160	6392	*/
6161	6393	if (do_sub) {
6162	6394	int xflags;
	6395	size_t ecount;
6163	6396	put_sub:
6164	6397	xdata.mv_size = 0;
6165	6398	xdata.mv_data = "";

6175	6408	if (dkey.mv_size) {
6176	6409	rc = mdb_cursor_put(&mc->mc_xcursor->mx_cursor, &dkey, &xdata, xflags);
6177	6410	if (rc)
6178		return rc;
	6411	goto bad_sub;
6179	6412	{
6180	6413	/* Adjust other cursors pointing to mp */
6181	6414	MDB_cursor *m2;

6193	6426	/* we've done our job */
6194	6427	dkey.mv_size = 0;
6195	6428	}
	6429	ecount = mc->mc_xcursor->mx_db.md_entries;
6196	6430	if (flags & MDB_APPENDDUP)
6197	6431	xflags \|= MDB_APPEND;
6198	6432	rc = mdb_cursor_put(&mc->mc_xcursor->mx_cursor, data, &xdata, xflags);

6200	6434	void *db = NODEDATA(leaf);
6201	6435	memcpy(db, &mc->mc_xcursor->mx_db, sizeof(MDB_db));
6202	6436	}
6203		}
6204		/* sub-writes might have failed so check rc again.
6205		* Don't increment count if we just replaced an existing item.
6206		*/
6207		if (!rc && !(flags & MDB_CURRENT))
	6437	insert_data = mc->mc_xcursor->mx_db.md_entries - ecount;
	6438	}
	6439	/* Increment count unless we just replaced an existing item. */
	6440	if (insert_data)
6208	6441	mc->mc_db->md_entries++;
	6442	if (insert_key) {
	6443	/* Invalidate txn if we created an empty sub-DB */
	6444	if (rc)
	6445	goto bad_sub;
	6446	/* If we succeeded and the key didn't exist before,
	6447	* make sure the cursor is marked valid.
	6448	*/
	6449	mc->mc_flags \|= C_INITIALIZED;
	6450	}
6209	6451	if (flags & MDB_MULTIPLE) {
6210	6452	if (!rc) {
6211		next_mult:
6212	6453	mcount++;
6213	6454	/* let caller know how many succeeded, if any */
6214	6455	data[1].mv_size = mcount;
6215	6456	if (mcount < dcount) {
6216	6457	data[0].mv_data = (char *)data[0].mv_data + data[0].mv_size;
	6458	insert_key = insert_data = 0;
6217	6459	goto more;
6218	6460	}
6219	6461	}
6220	6462	}
6221		}
6222		done:
6223		/* If we succeeded and the key didn't exist before, make sure
6224		* the cursor is marked valid.
6225		*/
6226		if (!rc && insert)
6227		mc->mc_flags \|= C_INITIALIZED;
	6463	return rc;
	6464	bad_sub:
	6465	if (rc == MDB_KEYEXIST) /* should not happen, we deleted that item */
	6466	rc = MDB_CORRUPTED;
	6467	}
	6468	mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
6228	6469	return rc;
6229	6470	}
6230	6471

6252	6493	return rc;
6253	6494
6254	6495	mp = mc->mc_pg[mc->mc_top];
	6496	if (IS_LEAF2(mp))
	6497	goto del_key;
6255	6498	leaf = NODEPTR(mp, mc->mc_ki[mc->mc_top]);
6256	6499
6257		if (!IS_LEAF2(mp) && F_ISSET(leaf->mn_flags, F_DUPDATA)) {
6258		if (!(flags & MDB_NODUPDATA)) {
	6500	if (F_ISSET(leaf->mn_flags, F_DUPDATA)) {
	6501	if (flags & MDB_NODUPDATA) {
	6502	/* mdb_cursor_del0() will subtract the final entry */
	6503	mc->mc_db->md_entries -= mc->mc_xcursor->mx_db.md_entries - 1;
	6504	} else {
6259	6505	if (!F_ISSET(leaf->mn_flags, F_SUBDATA)) {
6260	6506	mc->mc_xcursor->mx_cursor.mc_pg[0] = NODEDATA(leaf);
6261	6507	}
6262	6508	rc = mdb_cursor_del(&mc->mc_xcursor->mx_cursor, MDB_NOSPILL);
	6509	if (rc)
	6510	return rc;
6263	6511	/* If sub-DB still has entries, we're done */
6264	6512	if (mc->mc_xcursor->mx_db.md_entries) {
6265	6513	if (leaf->mn_flags & F_SUBDATA) {

6290	6538	if (leaf->mn_flags & F_SUBDATA) {
6291	6539	/* add all the child DB's pages to the free list */
6292	6540	rc = mdb_drop0(&mc->mc_xcursor->mx_cursor, 0);
6293		if (rc == MDB_SUCCESS) {
6294		mc->mc_db->md_entries -=
6295		mc->mc_xcursor->mx_db.md_entries;
6296		}
6297		}
6298		}
6299
6300		return mdb_cursor_del0(mc, leaf);
	6541	if (rc)
	6542	goto fail;
	6543	}
	6544	}
	6545
	6546	/* add overflow pages to free list */
	6547	if (F_ISSET(leaf->mn_flags, F_BIGDATA)) {
	6548	MDB_page *omp;
	6549	pgno_t pg;
	6550
	6551	memcpy(&pg, NODEDATA(leaf), sizeof(pg));
	6552	if ((rc = mdb_page_get(mc->mc_txn, pg, &omp, NULL)) \|\|
	6553	(rc = mdb_ovpage_free(mc, omp)))
	6554	goto fail;
	6555	}
	6556
	6557	del_key:
	6558	return mdb_cursor_del0(mc);
	6559
	6560	fail:
	6561	mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
	6562	return rc;
6301	6563	}
6302	6564
6303	6565	/** Allocate and initialize new pages for a database.

6319	6581	DPRINTF(("allocated new mpage %"Z"u, page size %u",
6320	6582	np->mp_pgno, mc->mc_txn->mt_env->me_psize));
6321	6583	np->mp_flags = flags \| P_DIRTY;
6322		np->mp_lower = PAGEHDRSZ;
6323		np->mp_upper = mc->mc_txn->mt_env->me_psize;
	6584	np->mp_lower = (PAGEHDRSZ-PAGEBASE);
	6585	np->mp_upper = mc->mc_txn->mt_env->me_psize - PAGEBASE;
6324	6586
6325	6587	if (IS_BRANCH(np))
6326	6588	mc->mc_db->md_branch_pages++;

6524	6786	}
6525	6787
6526	6788	/** Delete the specified node from a page.
6527		* @param[in] mp The page to operate on.
6528		* @param[in] indx The index of the node to delete.
	6789	* @param[in] mc Cursor pointing to the node to delete.
6529	6790	* @param[in] ksize The size of a node. Only used if the page is
6530	6791	* part of a #MDB_DUPFIXED database.
6531	6792	*/

6574	6835	}
6575	6836	}
6576	6837
6577		base = (char *)mp + mp->mp_upper;
	6838	base = (char *)mp + mp->mp_upper + PAGEBASE;
6578	6839	memmove(base + sz, base, ptr - mp->mp_upper);
6579	6840
6580	6841	mp->mp_lower -= sizeof(indx_t);

6628	6889	mp->mp_ptrs[i] += delta;
6629	6890	}
6630	6891
6631		base = (char *)mp + mp->mp_upper;
	6892	base = (char *)mp + mp->mp_upper + PAGEBASE;
6632	6893	memmove(base + delta, base, ptr - mp->mp_upper + NODESIZE + NODEKSZ(node));
6633	6894	mp->mp_upper += delta;
6634	6895	}

6707	6968	mx->mx_dbflag = DB_VALID\|DB_DIRTY; /* DB_DIRTY guides mdb_cursor_touch */
6708	6969	#if UINT_MAX < SIZE_MAX
6709	6970	if (mx->mx_dbx.md_cmp == mdb_cmp_int && mx->mx_db.md_pad == sizeof(size_t))
6710		#ifdef MISALIGNED_OK
6711		mx->mx_dbx.md_cmp = mdb_cmp_long;
6712		#else
6713		mx->mx_dbx.md_cmp = mdb_cmp_cint;
6714		#endif
	6971	mx->mx_dbx.md_cmp = mdb_cmp_clong;
6715	6972	#endif
6716	6973	}
6717	6974

6748	7005	MDB_cursor *mc;
6749	7006	size_t size = sizeof(MDB_cursor);
6750	7007
6751		if (txn == NULL \|\| ret == NULL \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	7008	if (!ret \|\| !TXN_DBI_EXIST(txn, dbi))
6752	7009	return EINVAL;
6753	7010
6754	7011	if (txn->mt_flags & MDB_TXN_ERROR)

6780	7037	int
6781	7038	mdb_cursor_renew(MDB_txn txn, MDB_cursor mc)
6782	7039	{
6783		if (txn == NULL \|\| mc == NULL \|\| mc->mc_dbi >= txn->mt_numdbs)
	7040	if (!mc \|\| !TXN_DBI_EXIST(txn, mc->mc_dbi))
6784	7041	return EINVAL;
6785	7042
6786	7043	if ((mc->mc_flags & C_UNTRACK) \|\| txn->mt_cursors)
6787	7044	return EINVAL;
	7045
	7046	if (txn->mt_flags & MDB_TXN_ERROR)
	7047	return MDB_BAD_TXN;
6788	7048
6789	7049	mdb_cursor_init(mc, txn, mc->mc_dbi, mc->mc_xcursor);
6790	7050	return MDB_SUCCESS;

6801	7061
6802	7062	if (mc->mc_xcursor == NULL)
6803	7063	return MDB_INCOMPATIBLE;
	7064
	7065	if (mc->mc_txn->mt_flags & MDB_TXN_ERROR)
	7066	return MDB_BAD_TXN;
	7067
	7068	if (!(mc->mc_flags & C_INITIALIZED))
	7069	return EINVAL;
	7070
	7071	if (!mc->mc_snum \|\| (mc->mc_flags & C_EOF))
	7072	return MDB_NOTFOUND;
6804	7073
6805	7074	leaf = NODEPTR(mc->mc_pg[mc->mc_top], mc->mc_ki[mc->mc_top]);
6806	7075	if (!F_ISSET(leaf->mn_flags, F_DUPDATA)) {

6898	7167	mp->mp_ptrs[i] -= delta;
6899	7168	}
6900	7169
6901		base = (char *)mp + mp->mp_upper;
	7170	base = (char *)mp + mp->mp_upper + PAGEBASE;
6902	7171	len = ptr - mp->mp_upper + NODESIZE;
6903	7172	memmove(base - delta, base, len);
6904	7173	mp->mp_upper -= delta;

6954	7223	unsigned int snum = csrc->mc_snum;
6955	7224	MDB_node *s2;
6956	7225	/* must find the lowest key below src */
6957		mdb_page_search_lowest(csrc);
	7226	rc = mdb_page_search_lowest(csrc);
	7227	if (rc)
	7228	return rc;
6958	7229	if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
6959	7230	key.mv_size = csrc->mc_db->md_pad;
6960	7231	key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], 0, key.mv_size);

6977	7248	MDB_node *s2;
6978	7249	MDB_val bkey;
6979	7250	/* must find the lowest key below dst */
6980		mdb_page_search_lowest(cdst);
6981		if (IS_LEAF2(cdst->mc_pg[cdst->mc_top])) {
6982		bkey.mv_size = cdst->mc_db->md_pad;
6983		bkey.mv_data = LEAF2KEY(cdst->mc_pg[cdst->mc_top], 0, bkey.mv_size);
	7251	mdb_cursor_copy(cdst, &mn);
	7252	rc = mdb_page_search_lowest(&mn);
	7253	if (rc)
	7254	return rc;
	7255	if (IS_LEAF2(mn.mc_pg[mn.mc_top])) {
	7256	bkey.mv_size = mn.mc_db->md_pad;
	7257	bkey.mv_data = LEAF2KEY(mn.mc_pg[mn.mc_top], 0, bkey.mv_size);
6984	7258	} else {
6985		s2 = NODEPTR(cdst->mc_pg[cdst->mc_top], 0);
	7259	s2 = NODEPTR(mn.mc_pg[mn.mc_top], 0);
6986	7260	bkey.mv_size = NODEKSZ(s2);
6987	7261	bkey.mv_data = NODEKEY(s2);
6988	7262	}
6989		cdst->mc_snum = snum--;
6990		cdst->mc_top = snum;
6991		mdb_cursor_copy(cdst, &mn);
	7263	mn.mc_snum = snum--;
	7264	mn.mc_top = snum;
6992	7265	mn.mc_ki[snum] = 0;
6993	7266	rc = mdb_update_key(&mn, &bkey);
6994	7267	if (rc)

7099	7372	* the \b csrc page will be freed.
7100	7373	* @param[in] csrc Cursor pointing to the source page.
7101	7374	* @param[in] cdst Cursor pointing to the destination page.
	7375	* @return 0 on success, non-zero on failure.
7102	7376	*/
7103	7377	static int
7104	7378	mdb_page_merge(MDB_cursor csrc, MDB_cursor cdst)
7105	7379	{
	7380	MDB_page psrc, pdst;
	7381	MDB_node *srcnode;
	7382	MDB_val key, data;
	7383	unsigned nkeys;
7106	7384	int rc;
7107		indx_t i, j;
7108		MDB_node *srcnode;
7109		MDB_val key, data;
7110		unsigned nkeys;
7111
7112		DPRINTF(("merging page %"Z"u into %"Z"u", csrc->mc_pg[csrc->mc_top]->mp_pgno,
7113		cdst->mc_pg[cdst->mc_top]->mp_pgno));
	7385	indx_t i, j;
	7386
	7387	psrc = csrc->mc_pg[csrc->mc_top];
	7388	pdst = cdst->mc_pg[cdst->mc_top];
	7389
	7390	DPRINTF(("merging page %"Z"u into %"Z"u", psrc->mp_pgno, pdst->mp_pgno));
7114	7391
7115	7392	mdb_cassert(csrc, csrc->mc_snum > 1); /* can't merge root page */
7116	7393	mdb_cassert(csrc, cdst->mc_snum > 1);

7121	7398
7122	7399	/* Move all nodes from src to dst.
7123	7400	*/
7124		j = nkeys = NUMKEYS(cdst->mc_pg[cdst->mc_top]);
7125		if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
	7401	j = nkeys = NUMKEYS(pdst);
	7402	if (IS_LEAF2(psrc)) {
7126	7403	key.mv_size = csrc->mc_db->md_pad;
7127		key.mv_data = METADATA(csrc->mc_pg[csrc->mc_top]);
7128		for (i = 0; i < NUMKEYS(csrc->mc_pg[csrc->mc_top]); i++, j++) {
	7404	key.mv_data = METADATA(psrc);
	7405	for (i = 0; i < NUMKEYS(psrc); i++, j++) {
7129	7406	rc = mdb_node_add(cdst, j, &key, NULL, 0, 0);
7130	7407	if (rc != MDB_SUCCESS)
7131	7408	return rc;
7132	7409	key.mv_data = (char *)key.mv_data + key.mv_size;
7133	7410	}
7134	7411	} else {
7135		for (i = 0; i < NUMKEYS(csrc->mc_pg[csrc->mc_top]); i++, j++) {
7136		srcnode = NODEPTR(csrc->mc_pg[csrc->mc_top], i);
7137		if (i == 0 && IS_BRANCH(csrc->mc_pg[csrc->mc_top])) {
7138		unsigned int snum = csrc->mc_snum;
	7412	for (i = 0; i < NUMKEYS(psrc); i++, j++) {
	7413	srcnode = NODEPTR(psrc, i);
	7414	if (i == 0 && IS_BRANCH(psrc)) {
	7415	MDB_cursor mn;
7139	7416	MDB_node *s2;
	7417	mdb_cursor_copy(csrc, &mn);
7140	7418	/* must find the lowest key below src */
7141		mdb_page_search_lowest(csrc);
7142		if (IS_LEAF2(csrc->mc_pg[csrc->mc_top])) {
7143		key.mv_size = csrc->mc_db->md_pad;
7144		key.mv_data = LEAF2KEY(csrc->mc_pg[csrc->mc_top], 0, key.mv_size);
	7419	rc = mdb_page_search_lowest(&mn);
	7420	if (rc)
	7421	return rc;
	7422	if (IS_LEAF2(mn.mc_pg[mn.mc_top])) {
	7423	key.mv_size = mn.mc_db->md_pad;
	7424	key.mv_data = LEAF2KEY(mn.mc_pg[mn.mc_top], 0, key.mv_size);
7145	7425	} else {
7146		s2 = NODEPTR(csrc->mc_pg[csrc->mc_top], 0);
	7426	s2 = NODEPTR(mn.mc_pg[mn.mc_top], 0);
7147	7427	key.mv_size = NODEKSZ(s2);
7148	7428	key.mv_data = NODEKEY(s2);
7149	7429	}
7150		csrc->mc_snum = snum--;
7151		csrc->mc_top = snum;
7152	7430	} else {
7153	7431	key.mv_size = srcnode->mn_ksize;
7154	7432	key.mv_data = NODEKEY(srcnode);

7163	7441	}
7164	7442
7165	7443	DPRINTF(("dst page %"Z"u now has %u keys (%.1f%% filled)",
7166		cdst->mc_pg[cdst->mc_top]->mp_pgno, NUMKEYS(cdst->mc_pg[cdst->mc_top]),
7167		(float)PAGEFILL(cdst->mc_txn->mt_env, cdst->mc_pg[cdst->mc_top]) / 10));
	7444	pdst->mp_pgno, NUMKEYS(pdst),
	7445	(float)PAGEFILL(cdst->mc_txn->mt_env, pdst) / 10));
7168	7446
7169	7447	/* Unlink the src page from parent and add to free list.
7170	7448	*/

7180	7458	}
7181	7459	csrc->mc_top++;
7182	7460
7183		rc = mdb_midl_append(&csrc->mc_txn->mt_free_pgs,
7184		csrc->mc_pg[csrc->mc_top]->mp_pgno);
	7461	psrc = csrc->mc_pg[csrc->mc_top];
	7462	/* If not operating on FreeDB, allow this page to be reused
	7463	* in this txn. Otherwise just add to free list.
	7464	*/
	7465	rc = mdb_page_loose(csrc, psrc);
7185	7466	if (rc)
7186	7467	return rc;
7187		if (IS_LEAF(csrc->mc_pg[csrc->mc_top]))
	7468	if (IS_LEAF(psrc))
7188	7469	csrc->mc_db->md_leaf_pages--;
7189	7470	else
7190	7471	csrc->mc_db->md_branch_pages--;

7192	7473	/* Adjust other cursors pointing to mp */
7193	7474	MDB_cursor m2, m3;
7194	7475	MDB_dbi dbi = csrc->mc_dbi;
7195		MDB_page *mp = cdst->mc_pg[cdst->mc_top];
7196	7476
7197	7477	for (m2 = csrc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
7198	7478	if (csrc->mc_flags & C_SUB)

7201	7481	m3 = m2;
7202	7482	if (m3 == csrc) continue;
7203	7483	if (m3->mc_snum < csrc->mc_snum) continue;
7204		if (m3->mc_pg[csrc->mc_top] == csrc->mc_pg[csrc->mc_top]) {
7205		m3->mc_pg[csrc->mc_top] = mp;
	7484	if (m3->mc_pg[csrc->mc_top] == psrc) {
	7485	m3->mc_pg[csrc->mc_top] = pdst;
7206	7486	m3->mc_ki[csrc->mc_top] += nkeys;
7207	7487	}
7208	7488	}
7209	7489	}
7210		mdb_cursor_pop(csrc);
7211
7212		return mdb_rebalance(csrc);
	7490	{
	7491	unsigned int snum = cdst->mc_snum;
	7492	uint16_t depth = cdst->mc_db->md_depth;
	7493	mdb_cursor_pop(cdst);
	7494	rc = mdb_rebalance(cdst);
	7495	/* Did the tree shrink? */
	7496	if (depth > cdst->mc_db->md_depth)
	7497	snum--;
	7498	cdst->mc_snum = snum;
	7499	cdst->mc_top = snum-1;
	7500	}
	7501	return rc;
7213	7502	}
7214	7503
7215	7504	/** Copy the contents of a cursor.

7247	7536	int rc;
7248	7537	unsigned int ptop, minkeys;
7249	7538	MDB_cursor mn;
	7539	indx_t oldki;
7250	7540
7251	7541	minkeys = 1 + (IS_BRANCH(mc->mc_pg[mc->mc_top]));
7252	7542	DPRINTF(("rebalancing %s page %"Z"u (has %u keys, %.1f%% full)",

7297	7587	}
7298	7588	}
7299	7589	} else if (IS_BRANCH(mp) && NUMKEYS(mp) == 1) {
	7590	int i;
7300	7591	DPUTS("collapsing root page!");
7301	7592	rc = mdb_midl_append(&mc->mc_txn->mt_free_pgs, mp->mp_pgno);
7302	7593	if (rc)

7308	7599	mc->mc_db->md_depth--;
7309	7600	mc->mc_db->md_branch_pages--;
7310	7601	mc->mc_ki[0] = mc->mc_ki[1];
	7602	for (i = 1; i<mc->mc_db->md_depth; i++) {
	7603	mc->mc_pg[i] = mc->mc_pg[i+1];
	7604	mc->mc_ki[i] = mc->mc_ki[i+1];
	7605	}
7311	7606	{
7312	7607	/* Adjust other cursors pointing to mp */
7313	7608	MDB_cursor m2, m3;

7320	7615	m3 = m2;
7321	7616	if (m3 == mc \|\| m3->mc_snum < mc->mc_snum) continue;
7322	7617	if (m3->mc_pg[0] == mp) {
7323		int i;
7324	7618	m3->mc_snum--;
7325	7619	m3->mc_top--;
7326	7620	for (i=0; i<m3->mc_snum; i++) {

7351	7645	mdb_cursor_copy(mc, &mn);
7352	7646	mn.mc_xcursor = NULL;
7353	7647
	7648	oldki = mc->mc_ki[mc->mc_top];
7354	7649	if (mc->mc_ki[ptop] == 0) {
7355	7650	/* We're the leftmost leaf in our parent.
7356	7651	*/

7384	7679	* (A branch page must never have less than 2 keys.)
7385	7680	*/
7386	7681	minkeys = 1 + (IS_BRANCH(mn.mc_pg[mn.mc_top]));
7387		if (PAGEFILL(mc->mc_txn->mt_env, mn.mc_pg[mn.mc_top]) >= FILL_THRESHOLD && NUMKEYS(mn.mc_pg[mn.mc_top]) > minkeys)
7388		return mdb_node_move(&mn, mc);
7389		else {
7390		if (mc->mc_ki[ptop] == 0)
	7682	if (PAGEFILL(mc->mc_txn->mt_env, mn.mc_pg[mn.mc_top]) >= FILL_THRESHOLD && NUMKEYS(mn.mc_pg[mn.mc_top]) > minkeys) {
	7683	rc = mdb_node_move(&mn, mc);
	7684	if (mc->mc_ki[ptop]) {
	7685	oldki++;
	7686	}
	7687	} else {
	7688	if (mc->mc_ki[ptop] == 0) {
7391	7689	rc = mdb_page_merge(&mn, mc);
7392		else {
	7690	} else {
	7691	oldki += NUMKEYS(mn.mc_pg[mn.mc_top]);
7393	7692	mn.mc_ki[mn.mc_top] += mc->mc_ki[mn.mc_top] + 1;
7394	7693	rc = mdb_page_merge(mc, &mn);
7395	7694	mdb_cursor_copy(&mn, mc);
7396	7695	}
7397		mc->mc_flags &= ~(C_INITIALIZED\|C_EOF);
7398		}
	7696	mc->mc_flags &= ~C_EOF;
	7697	}
	7698	mc->mc_ki[mc->mc_top] = oldki;
7399	7699	return rc;
7400	7700	}
7401	7701
7402	7702	/** Complete a delete operation started by #mdb_cursor_del(). */
7403	7703	static int
7404		mdb_cursor_del0(MDB_cursor mc, MDB_node leaf)
	7704	mdb_cursor_del0(MDB_cursor *mc)
7405	7705	{
7406	7706	int rc;
7407	7707	MDB_page *mp;
7408	7708	indx_t ki;
7409	7709	unsigned int nkeys;
7410	7710
7411		mp = mc->mc_pg[mc->mc_top];
7412	7711	ki = mc->mc_ki[mc->mc_top];
7413
7414		/* add overflow pages to free list */
7415		if (!IS_LEAF2(mp) && F_ISSET(leaf->mn_flags, F_BIGDATA)) {
7416		MDB_page *omp;
7417		pgno_t pg;
7418
7419		memcpy(&pg, NODEDATA(leaf), sizeof(pg));
7420		if ((rc = mdb_page_get(mc->mc_txn, pg, &omp, NULL)) \|\|
7421		(rc = mdb_ovpage_free(mc, omp)))
7422		return rc;
7423		}
7424	7712	mdb_node_del(mc, mc->mc_db->md_pad);
7425	7713	mc->mc_db->md_entries--;
7426	7714	rc = mdb_rebalance(mc);
7427		if (rc != MDB_SUCCESS)
7428		mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
7429		else {
	7715
	7716	if (rc == MDB_SUCCESS) {
7430	7717	MDB_cursor m2, m3;
7431	7718	MDB_dbi dbi = mc->mc_dbi;
7432	7719

7434	7721	nkeys = NUMKEYS(mp);
7435	7722
7436	7723	/* if mc points past last node in page, find next sibling */
7437		if (mc->mc_ki[mc->mc_top] >= nkeys)
7438		mdb_cursor_sibling(mc, 1);
	7724	if (mc->mc_ki[mc->mc_top] >= nkeys) {
	7725	rc = mdb_cursor_sibling(mc, 1);
	7726	if (rc == MDB_NOTFOUND) {
	7727	mc->mc_flags \|= C_EOF;
	7728	rc = MDB_SUCCESS;
	7729	}
	7730	}
7439	7731
7440	7732	/* Adjust other cursors pointing to mp */
7441		for (m2 = mc->mc_txn->mt_cursors[dbi]; m2; m2=m2->mc_next) {
	7733	for (m2 = mc->mc_txn->mt_cursors[dbi]; !rc && m2; m2=m2->mc_next) {
7442	7734	m3 = (mc->mc_flags & C_SUB) ? &m2->mc_xcursor->mx_cursor : m2;
7443	7735	if (! (m2->mc_flags & m3->mc_flags & C_INITIALIZED))
7444	7736	continue;

7449	7741	m3->mc_flags \|= C_DEL;
7450	7742	if (m3->mc_ki[mc->mc_top] > ki)
7451	7743	m3->mc_ki[mc->mc_top]--;
	7744	else if (mc->mc_db->md_flags & MDB_DUPSORT)
	7745	m3->mc_xcursor->mx_cursor.mc_flags \|= C_EOF;
7452	7746	}
7453		if (m3->mc_ki[mc->mc_top] >= nkeys)
7454		mdb_cursor_sibling(m3, 1);
	7747	if (m3->mc_ki[mc->mc_top] >= nkeys) {
	7748	rc = mdb_cursor_sibling(m3, 1);
	7749	if (rc == MDB_NOTFOUND) {
	7750	m3->mc_flags \|= C_EOF;
	7751	rc = MDB_SUCCESS;
	7752	}
	7753	}
7455	7754	}
7456	7755	}
7457	7756	mc->mc_flags \|= C_DEL;
7458	7757	}
7459	7758
	7759	if (rc)
	7760	mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
7460	7761	return rc;
7461	7762	}
7462	7763
7463	7764	int
7464	7765	mdb_del(MDB_txn *txn, MDB_dbi dbi,
7465	7766	MDB_val key, MDB_val data)
	7767	{
	7768	if (!key \|\| dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
	7769	return EINVAL;
	7770
	7771	if (txn->mt_flags & (MDB_TXN_RDONLY\|MDB_TXN_ERROR))
	7772	return (txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
	7773
	7774	if (!F_ISSET(txn->mt_dbs[dbi].md_flags, MDB_DUPSORT)) {
	7775	/* must ignore any data */
	7776	data = NULL;
	7777	}
	7778
	7779	return mdb_del0(txn, dbi, key, data, 0);
	7780	}
	7781
	7782	static int
	7783	mdb_del0(MDB_txn *txn, MDB_dbi dbi,
	7784	MDB_val key, MDB_val data, unsigned flags)
7466	7785	{
7467	7786	MDB_cursor mc;
7468	7787	MDB_xcursor mx;
7469	7788	MDB_cursor_op op;
7470	7789	MDB_val rdata, *xdata;
7471		int rc, exact;
	7790	int rc, exact = 0;
7472	7791	DKBUF;
7473	7792
7474		if (key == NULL)
7475		return EINVAL;
7476
7477	7793	DPRINTF(("====> delete db %u key [%s]", dbi, DKEY(key)));
7478	7794
7479		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
7480		return EINVAL;
7481
7482		if (txn->mt_flags & (MDB_TXN_RDONLY\|MDB_TXN_ERROR))
7483		return (txn->mt_flags & MDB_TXN_RDONLY) ? EACCES : MDB_BAD_TXN;
7484
7485	7795	mdb_cursor_init(&mc, txn, dbi, &mx);
7486	7796
7487		exact = 0;
7488		if (!F_ISSET(txn->mt_dbs[dbi].md_flags, MDB_DUPSORT)) {
7489		/* must ignore any data */
7490		data = NULL;
7491		}
7492	7797	if (data) {
7493	7798	op = MDB_GET_BOTH;
7494	7799	rdata = *data;

7496	7801	} else {
7497	7802	op = MDB_SET;
7498	7803	xdata = NULL;
	7804	flags \|= MDB_NODUPDATA;
7499	7805	}
7500	7806	rc = mdb_cursor_set(&mc, key, xdata, op, &exact);
7501	7807	if (rc == 0) {

7510	7816	mc.mc_flags \|= C_UNTRACK;
7511	7817	mc.mc_next = txn->mt_cursors[dbi];
7512	7818	txn->mt_cursors[dbi] = &mc;
7513		rc = mdb_cursor_del(&mc, data ? 0 : MDB_NODUPDATA);
	7819	rc = mdb_cursor_del(&mc, flags);
7514	7820	txn->mt_cursors[dbi] = mc.mc_next;
7515	7821	}
7516	7822	return rc;

7559	7865
7560	7866	if (mc->mc_snum < 2) {
7561	7867	if ((rc = mdb_page_new(mc, P_BRANCH, 1, &pp)))
7562		return rc;
	7868	goto done;
7563	7869	/* shift current top to make room for new parent */
7564	7870	mc->mc_pg[1] = mc->mc_pg[0];
7565	7871	mc->mc_ki[1] = mc->mc_ki[0];

7577	7883	mc->mc_ki[0] = mc->mc_ki[1];
7578	7884	mc->mc_db->md_root = mp->mp_pgno;
7579	7885	mc->mc_db->md_depth--;
7580		return rc;
	7886	goto done;
7581	7887	}
7582	7888	mc->mc_snum = 2;
7583	7889	mc->mc_top = 1;

7606	7912	int x;
7607	7913	unsigned int lsize, rsize, ksize;
7608	7914	/* Move half of the keys to the right sibling */
7609		copy = NULL;
7610	7915	x = mc->mc_ki[mc->mc_top] - split_indx;
7611	7916	ksize = mc->mc_db->md_pad;
7612	7917	split = LEAF2KEY(mp, split_indx, ksize);

7653	7958
7654	7959	/* grab a page to hold a temporary copy */
7655	7960	copy = mdb_page_malloc(mc->mc_txn, 1);
7656		if (copy == NULL)
7657		return ENOMEM;
	7961	if (copy == NULL) {
	7962	rc = ENOMEM;
	7963	goto done;
	7964	}
7658	7965	copy->mp_pgno = mp->mp_pgno;
7659	7966	copy->mp_flags = mp->mp_flags;
7660		copy->mp_lower = PAGEHDRSZ;
7661		copy->mp_upper = env->me_psize;
	7967	copy->mp_lower = (PAGEHDRSZ-PAGEBASE);
	7968	copy->mp_upper = env->me_psize - PAGEBASE;
7662	7969
7663	7970	/* prepare to insert */
7664	7971	for (i=0, j=0; i<nkeys; i++) {

7698	8005	psize += nsize;
7699	8006	node = NULL;
7700	8007	} else {
7701		node = (MDB_node )((char )mp + copy->mp_ptrs[i]);
	8008	node = (MDB_node )((char )mp + copy->mp_ptrs[i] + PAGEBASE);
7702	8009	psize += NODESIZE + NODEKSZ(node) + sizeof(indx_t);
7703	8010	if (IS_LEAF(mp)) {
7704	8011	if (F_ISSET(node->mn_flags, F_BIGDATA))

7718	8025	sepkey.mv_size = newkey->mv_size;
7719	8026	sepkey.mv_data = newkey->mv_data;
7720	8027	} else {
7721		node = (MDB_node )((char )mp + copy->mp_ptrs[split_indx]);
	8028	node = (MDB_node )((char )mp + copy->mp_ptrs[split_indx] + PAGEBASE);
7722	8029	sepkey.mv_size = node->mn_ksize;
7723	8030	sepkey.mv_data = NODEKEY(node);
7724	8031	}

7734	8041	mn.mc_top--;
7735	8042	did_split = 1;
7736	8043	rc = mdb_page_split(&mn, &sepkey, NULL, rp->mp_pgno, 0);
	8044	if (rc)
	8045	goto done;
7737	8046
7738	8047	/* root split? */
7739	8048	if (mn.mc_snum == mc->mc_snum) {

7755	8064	mc->mc_ki[i] = mn.mc_ki[i];
7756	8065	}
7757	8066	mc->mc_pg[ptop] = mn.mc_pg[ptop];
7758		mc->mc_ki[ptop] = mn.mc_ki[ptop] - 1;
	8067	if (mn.mc_ki[ptop]) {
	8068	mc->mc_ki[ptop] = mn.mc_ki[ptop] - 1;
	8069	} else {
	8070	/* find right page's left sibling */
	8071	mc->mc_ki[ptop] = mn.mc_ki[ptop];
	8072	mdb_cursor_sibling(mc, 0);
	8073	}
7759	8074	}
7760	8075	} else {
7761	8076	mn.mc_top--;

7764	8079	}
7765	8080	mc->mc_flags ^= C_SPLITTING;
7766	8081	if (rc != MDB_SUCCESS) {
7767		return rc;
	8082	goto done;
7768	8083	}
7769	8084	if (nflags & MDB_APPEND) {
7770	8085	mc->mc_pg[mc->mc_top] = rp;
7771	8086	mc->mc_ki[mc->mc_top] = 0;
7772	8087	rc = mdb_node_add(mc, 0, newkey, newdata, newpgno, nflags);
7773	8088	if (rc)
7774		return rc;
	8089	goto done;
7775	8090	for (i=0; i<mc->mc_top; i++)
7776	8091	mc->mc_ki[i] = mn.mc_ki[i];
7777	8092	} else if (!IS_LEAF2(mp)) {

7791	8106	/* Update index for the new key. */
7792	8107	mc->mc_ki[mc->mc_top] = j;
7793	8108	} else {
7794		node = (MDB_node )((char )mp + copy->mp_ptrs[i]);
	8109	node = (MDB_node )((char )mp + copy->mp_ptrs[i] + PAGEBASE);
7795	8110	rkey.mv_data = NODEKEY(node);
7796	8111	rkey.mv_size = node->mn_ksize;
7797	8112	if (IS_LEAF(mp)) {

7809	8124	}
7810	8125
7811	8126	rc = mdb_node_add(mc, j, &rkey, rdata, pgno, flags);
7812		if (rc) {
7813		/* return tmp page to freelist */
7814		mdb_page_free(env, copy);
7815		return rc;
7816		}
	8127	if (rc)
	8128	goto done;
7817	8129	if (i == nkeys) {
7818	8130	i = 0;
7819	8131	j = 0;

7830	8142	mp->mp_lower = copy->mp_lower;
7831	8143	mp->mp_upper = copy->mp_upper;
7832	8144	memcpy(NODEPTR(mp, nkeys-1), NODEPTR(copy, nkeys-1),
7833		env->me_psize - copy->mp_upper);
	8145	env->me_psize - copy->mp_upper - PAGEBASE);
7834	8146
7835	8147	/* reset back to original page */
7836	8148	if (newindx < split_indx) {

7847	8159	*/
7848	8160	if (mn.mc_pg[ptop] != mc->mc_pg[ptop] &&
7849	8161	mc->mc_ki[ptop] >= NUMKEYS(mc->mc_pg[ptop])) {
7850		for (i=0; i<ptop; i++) {
	8162	for (i=0; i<=ptop; i++) {
7851	8163	mc->mc_pg[i] = mn.mc_pg[i];
7852	8164	mc->mc_ki[i] = mn.mc_ki[i];
7853	8165	}
7854		mc->mc_pg[ptop] = mn.mc_pg[ptop];
7855		mc->mc_ki[ptop] = mn.mc_ki[ptop] - 1;
7856		}
7857		}
7858		/* return tmp page to freelist */
7859		mdb_page_free(env, copy);
	8166	}
	8167	}
7860	8168	}
7861	8169
7862	8170	{

7907	8215	}
7908	8216	}
7909	8217	DPRINTF(("mp left: %d, rp left: %d", SIZELEFT(mp), SIZELEFT(rp)));
	8218
	8219	done:
	8220	if (copy) /* tmp page */
	8221	mdb_page_free(env, copy);
	8222	if (rc)
	8223	mc->mc_txn->mt_flags \|= MDB_TXN_ERROR;
7910	8224	return rc;
7911	8225	}
7912	8226

7917	8231	MDB_cursor mc;
7918	8232	MDB_xcursor mx;
7919	8233
7920		if (key == NULL \|\| data == NULL)
7921		return EINVAL;
7922
7923		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	8234	if (!key \|\| !data \|\| dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
7924	8235	return EINVAL;
7925	8236
7926	8237	if ((flags & (MDB_NOOVERWRITE\|MDB_NODUPDATA\|MDB_RESERVE\|MDB_APPEND\|MDB_APPENDDUP)) != flags)

7930	8241	return mdb_cursor_put(&mc, key, data, flags);
7931	8242	}
7932	8243
7933		int
	8244	#ifndef MDB_WBUF
	8245	#define MDB_WBUF (1024*1024)
	8246	#endif
	8247
	8248	/** State needed for a compacting copy. */
	8249	typedef struct mdb_copy {
	8250	pthread_mutex_t mc_mutex;
	8251	pthread_cond_t mc_cond;
	8252	char *mc_wbuf[2];
	8253	char *mc_over[2];
	8254	MDB_env *mc_env;
	8255	MDB_txn *mc_txn;
	8256	int mc_wlen[2];
	8257	int mc_olen[2];
	8258	pgno_t mc_next_pgno;
	8259	HANDLE mc_fd;
	8260	int mc_status;
	8261	volatile int mc_new;
	8262	int mc_toggle;
	8263
	8264	} mdb_copy;
	8265
	8266	/** Dedicated writer thread for compacting copy. */
	8267	static THREAD_RET ESECT
	8268	mdb_env_copythr(void *arg)
	8269	{
	8270	mdb_copy *my = arg;
	8271	char *ptr;
	8272	int toggle = 0, wsize, rc;
	8273	#ifdef _WIN32
	8274	DWORD len;
	8275	#define DO_WRITE(rc, fd, ptr, w2, len) rc = WriteFile(fd, ptr, w2, &len, NULL)
	8276	#else
	8277	int len;
	8278	#define DO_WRITE(rc, fd, ptr, w2, len) len = write(fd, ptr, w2); rc = (len >= 0)
	8279	#endif
	8280
	8281	pthread_mutex_lock(&my->mc_mutex);
	8282	my->mc_new = 0;
	8283	pthread_cond_signal(&my->mc_cond);
	8284	for(;;) {
	8285	while (!my->mc_new)
	8286	pthread_cond_wait(&my->mc_cond, &my->mc_mutex);
	8287	if (my->mc_new < 0) {
	8288	my->mc_new = 0;
	8289	break;
	8290	}
	8291	my->mc_new = 0;
	8292	wsize = my->mc_wlen[toggle];
	8293	ptr = my->mc_wbuf[toggle];
	8294	again:
	8295	while (wsize > 0) {
	8296	DO_WRITE(rc, my->mc_fd, ptr, wsize, len);
	8297	if (!rc) {
	8298	rc = ErrCode();
	8299	break;
	8300	} else if (len > 0) {
	8301	rc = MDB_SUCCESS;
	8302	ptr += len;
	8303	wsize -= len;
	8304	continue;
	8305	} else {
	8306	rc = EIO;
	8307	break;
	8308	}
	8309	}
	8310	if (rc) {
	8311	my->mc_status = rc;
	8312	break;
	8313	}
	8314	/* If there's an overflow page tail, write it too */
	8315	if (my->mc_olen[toggle]) {
	8316	wsize = my->mc_olen[toggle];
	8317	ptr = my->mc_over[toggle];
	8318	my->mc_olen[toggle] = 0;
	8319	goto again;
	8320	}
	8321	my->mc_wlen[toggle] = 0;
	8322	toggle ^= 1;
	8323	pthread_cond_signal(&my->mc_cond);
	8324	}
	8325	pthread_cond_signal(&my->mc_cond);
	8326	pthread_mutex_unlock(&my->mc_mutex);
	8327	return (THREAD_RET)0;
	8328	#undef DO_WRITE
	8329	}
	8330
	8331	/** Tell the writer thread there's a buffer ready to write */
	8332	static int ESECT
	8333	mdb_env_cthr_toggle(mdb_copy *my, int st)
	8334	{
	8335	int toggle = my->mc_toggle ^ 1;
	8336	pthread_mutex_lock(&my->mc_mutex);
	8337	if (my->mc_status) {
	8338	pthread_mutex_unlock(&my->mc_mutex);
	8339	return my->mc_status;
	8340	}
	8341	while (my->mc_new == 1)
	8342	pthread_cond_wait(&my->mc_cond, &my->mc_mutex);
	8343	my->mc_new = st;
	8344	my->mc_toggle = toggle;
	8345	pthread_cond_signal(&my->mc_cond);
	8346	pthread_mutex_unlock(&my->mc_mutex);
	8347	return 0;
	8348	}
	8349
	8350	/** Depth-first tree traversal for compacting copy. */
	8351	static int ESECT
	8352	mdb_env_cwalk(mdb_copy my, pgno_t pg, int flags)
	8353	{
	8354	MDB_cursor mc;
	8355	MDB_txn *txn = my->mc_txn;
	8356	MDB_node *ni;
	8357	MDB_page mo, mp, *leaf;
	8358	char buf, ptr;
	8359	int rc, toggle;
	8360	unsigned int i;
	8361
	8362	/* Empty DB, nothing to do */
	8363	if (*pg == P_INVALID)
	8364	return MDB_SUCCESS;
	8365
	8366	mc.mc_snum = 1;
	8367	mc.mc_top = 0;
	8368	mc.mc_txn = txn;
	8369
	8370	rc = mdb_page_get(my->mc_txn, *pg, &mc.mc_pg[0], NULL);
	8371	if (rc)
	8372	return rc;
	8373	rc = mdb_page_search_root(&mc, NULL, MDB_PS_FIRST);
	8374	if (rc)
	8375	return rc;
	8376
	8377	/* Make cursor pages writable */
	8378	buf = ptr = malloc(my->mc_env->me_psize * mc.mc_snum);
	8379	if (buf == NULL)
	8380	return ENOMEM;
	8381
	8382	for (i=0; i<mc.mc_top; i++) {
	8383	mdb_page_copy((MDB_page *)ptr, mc.mc_pg[i], my->mc_env->me_psize);
	8384	mc.mc_pg[i] = (MDB_page *)ptr;
	8385	ptr += my->mc_env->me_psize;
	8386	}
	8387
	8388	/* This is writable space for a leaf page. Usually not needed. */
	8389	leaf = (MDB_page *)ptr;
	8390
	8391	toggle = my->mc_toggle;
	8392	while (mc.mc_snum > 0) {
	8393	unsigned n;
	8394	mp = mc.mc_pg[mc.mc_top];
	8395	n = NUMKEYS(mp);
	8396
	8397	if (IS_LEAF(mp)) {
	8398	if (!IS_LEAF2(mp) && !(flags & F_DUPDATA)) {
	8399	for (i=0; i<n; i++) {
	8400	ni = NODEPTR(mp, i);
	8401	if (ni->mn_flags & F_BIGDATA) {
	8402	MDB_page *omp;
	8403	pgno_t pg;
	8404
	8405	/* Need writable leaf */
	8406	if (mp != leaf) {
	8407	mc.mc_pg[mc.mc_top] = leaf;
	8408	mdb_page_copy(leaf, mp, my->mc_env->me_psize);
	8409	mp = leaf;
	8410	ni = NODEPTR(mp, i);
	8411	}
	8412
	8413	memcpy(&pg, NODEDATA(ni), sizeof(pg));
	8414	rc = mdb_page_get(txn, pg, &omp, NULL);
	8415	if (rc)
	8416	goto done;
	8417	if (my->mc_wlen[toggle] >= MDB_WBUF) {
	8418	rc = mdb_env_cthr_toggle(my, 1);
	8419	if (rc)
	8420	goto done;
	8421	toggle = my->mc_toggle;
	8422	}
	8423	mo = (MDB_page *)(my->mc_wbuf[toggle] + my->mc_wlen[toggle]);
	8424	memcpy(mo, omp, my->mc_env->me_psize);
	8425	mo->mp_pgno = my->mc_next_pgno;
	8426	my->mc_next_pgno += omp->mp_pages;
	8427	my->mc_wlen[toggle] += my->mc_env->me_psize;
	8428	if (omp->mp_pages > 1) {
	8429	my->mc_olen[toggle] = my->mc_env->me_psize * (omp->mp_pages - 1);
	8430	my->mc_over[toggle] = (char *)omp + my->mc_env->me_psize;
	8431	rc = mdb_env_cthr_toggle(my, 1);
	8432	if (rc)
	8433	goto done;
	8434	toggle = my->mc_toggle;
	8435	}
	8436	memcpy(NODEDATA(ni), &mo->mp_pgno, sizeof(pgno_t));
	8437	} else if (ni->mn_flags & F_SUBDATA) {
	8438	MDB_db db;
	8439
	8440	/* Need writable leaf */
	8441	if (mp != leaf) {
	8442	mc.mc_pg[mc.mc_top] = leaf;
	8443	mdb_page_copy(leaf, mp, my->mc_env->me_psize);
	8444	mp = leaf;
	8445	ni = NODEPTR(mp, i);
	8446	}
	8447
	8448	memcpy(&db, NODEDATA(ni), sizeof(db));
	8449	my->mc_toggle = toggle;
	8450	rc = mdb_env_cwalk(my, &db.md_root, ni->mn_flags & F_DUPDATA);
	8451	if (rc)
	8452	goto done;
	8453	toggle = my->mc_toggle;
	8454	memcpy(NODEDATA(ni), &db, sizeof(db));
	8455	}
	8456	}
	8457	}
	8458	} else {
	8459	mc.mc_ki[mc.mc_top]++;
	8460	if (mc.mc_ki[mc.mc_top] < n) {
	8461	pgno_t pg;
	8462	again:
	8463	ni = NODEPTR(mp, mc.mc_ki[mc.mc_top]);
	8464	pg = NODEPGNO(ni);
	8465	rc = mdb_page_get(txn, pg, &mp, NULL);
	8466	if (rc)
	8467	goto done;
	8468	mc.mc_top++;
	8469	mc.mc_snum++;
	8470	mc.mc_ki[mc.mc_top] = 0;
	8471	if (IS_BRANCH(mp)) {
	8472	/* Whenever we advance to a sibling branch page,
	8473	* we must proceed all the way down to its first leaf.
	8474	*/
	8475	mdb_page_copy(mc.mc_pg[mc.mc_top], mp, my->mc_env->me_psize);
	8476	goto again;
	8477	} else
	8478	mc.mc_pg[mc.mc_top] = mp;
	8479	continue;
	8480	}
	8481	}
	8482	if (my->mc_wlen[toggle] >= MDB_WBUF) {
	8483	rc = mdb_env_cthr_toggle(my, 1);
	8484	if (rc)
	8485	goto done;
	8486	toggle = my->mc_toggle;
	8487	}
	8488	mo = (MDB_page *)(my->mc_wbuf[toggle] + my->mc_wlen[toggle]);
	8489	mdb_page_copy(mo, mp, my->mc_env->me_psize);
	8490	mo->mp_pgno = my->mc_next_pgno++;
	8491	my->mc_wlen[toggle] += my->mc_env->me_psize;
	8492	if (mc.mc_top) {
	8493	/* Update parent if there is one */
	8494	ni = NODEPTR(mc.mc_pg[mc.mc_top-1], mc.mc_ki[mc.mc_top-1]);
	8495	SETPGNO(ni, mo->mp_pgno);
	8496	mdb_cursor_pop(&mc);
	8497	} else {
	8498	/* Otherwise we're done */
	8499	*pg = mo->mp_pgno;
	8500	break;
	8501	}
	8502	}
	8503	done:
	8504	free(buf);
	8505	return rc;
	8506	}
	8507
	8508	/** Copy environment with compaction. */
	8509	static int ESECT
	8510	mdb_env_copyfd1(MDB_env *env, HANDLE fd)
	8511	{
	8512	MDB_meta *mm;
	8513	MDB_page *mp;
	8514	mdb_copy my;
	8515	MDB_txn *txn = NULL;
	8516	pthread_t thr;
	8517	int rc;
	8518
	8519	#ifdef _WIN32
	8520	my.mc_mutex = CreateMutex(NULL, FALSE, NULL);
	8521	my.mc_cond = CreateEvent(NULL, FALSE, FALSE, NULL);
	8522	my.mc_wbuf[0] = _aligned_malloc(MDB_WBUF*2, env->me_os_psize);
	8523	if (my.mc_wbuf[0] == NULL)
	8524	return errno;
	8525	#else
	8526	pthread_mutex_init(&my.mc_mutex, NULL);
	8527	pthread_cond_init(&my.mc_cond, NULL);
	8528	#ifdef HAVE_MEMALIGN
	8529	my.mc_wbuf[0] = memalign(env->me_os_psize, MDB_WBUF*2);
	8530	if (my.mc_wbuf[0] == NULL)
	8531	return errno;
	8532	#else
	8533	rc = posix_memalign((void *)&my.mc_wbuf[0], env->me_os_psize, MDB_WBUF2);
	8534	if (rc)
	8535	return rc;
	8536	#endif
	8537	#endif
	8538	memset(my.mc_wbuf[0], 0, MDB_WBUF*2);
	8539	my.mc_wbuf[1] = my.mc_wbuf[0] + MDB_WBUF;
	8540	my.mc_wlen[0] = 0;
	8541	my.mc_wlen[1] = 0;
	8542	my.mc_olen[0] = 0;
	8543	my.mc_olen[1] = 0;
	8544	my.mc_next_pgno = 2;
	8545	my.mc_status = 0;
	8546	my.mc_new = 1;
	8547	my.mc_toggle = 0;
	8548	my.mc_env = env;
	8549	my.mc_fd = fd;
	8550	THREAD_CREATE(thr, mdb_env_copythr, &my);
	8551
	8552	rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
	8553	if (rc)
	8554	return rc;
	8555
	8556	mp = (MDB_page *)my.mc_wbuf[0];
	8557	memset(mp, 0, 2*env->me_psize);
	8558	mp->mp_pgno = 0;
	8559	mp->mp_flags = P_META;
	8560	mm = (MDB_meta *)METADATA(mp);
	8561	mdb_env_init_meta0(env, mm);
	8562	mm->mm_address = env->me_metas[0]->mm_address;
	8563
	8564	mp = (MDB_page *)(my.mc_wbuf[0] + env->me_psize);
	8565	mp->mp_pgno = 1;
	8566	mp->mp_flags = P_META;
	8567	(MDB_meta )METADATA(mp) = *mm;
	8568	mm = (MDB_meta *)METADATA(mp);
	8569
	8570	/* Count the number of free pages, subtract from lastpg to find
	8571	* number of active pages
	8572	*/
	8573	{
	8574	MDB_ID freecount = 0;
	8575	MDB_cursor mc;
	8576	MDB_val key, data;
	8577	mdb_cursor_init(&mc, txn, FREE_DBI, NULL);
	8578	while ((rc = mdb_cursor_get(&mc, &key, &data, MDB_NEXT)) == 0)
	8579	freecount += (MDB_ID )data.mv_data;
	8580	freecount += txn->mt_dbs[0].md_branch_pages +
	8581	txn->mt_dbs[0].md_leaf_pages +
	8582	txn->mt_dbs[0].md_overflow_pages;
	8583
	8584	/* Set metapage 1 */
	8585	mm->mm_last_pg = txn->mt_next_pgno - freecount - 1;
	8586	mm->mm_dbs[1] = txn->mt_dbs[1];
	8587	mm->mm_dbs[1].md_root = mm->mm_last_pg;
	8588	mm->mm_txnid = 1;
	8589	}
	8590	my.mc_wlen[0] = env->me_psize * 2;
	8591	my.mc_txn = txn;
	8592	pthread_mutex_lock(&my.mc_mutex);
	8593	while(my.mc_new)
	8594	pthread_cond_wait(&my.mc_cond, &my.mc_mutex);
	8595	pthread_mutex_unlock(&my.mc_mutex);
	8596	rc = mdb_env_cwalk(&my, &txn->mt_dbs[1].md_root, 0);
	8597	if (rc == MDB_SUCCESS && my.mc_wlen[my.mc_toggle])
	8598	rc = mdb_env_cthr_toggle(&my, 1);
	8599	mdb_env_cthr_toggle(&my, -1);
	8600	pthread_mutex_lock(&my.mc_mutex);
	8601	while(my.mc_new)
	8602	pthread_cond_wait(&my.mc_cond, &my.mc_mutex);
	8603	pthread_mutex_unlock(&my.mc_mutex);
	8604	THREAD_FINISH(thr);
	8605
	8606	mdb_txn_abort(txn);
	8607	#ifdef _WIN32
	8608	CloseHandle(my.mc_cond);
	8609	CloseHandle(my.mc_mutex);
	8610	_aligned_free(my.mc_wbuf[0]);
	8611	#else
	8612	pthread_cond_destroy(&my.mc_cond);
	8613	pthread_mutex_destroy(&my.mc_mutex);
	8614	free(my.mc_wbuf[0]);
	8615	#endif
	8616	return rc;
	8617	}
	8618
	8619	/** Copy environment as-is. */
	8620	static int ESECT
	8621	mdb_env_copyfd0(MDB_env *env, HANDLE fd)
	8622	{
	8623	MDB_txn *txn = NULL;
	8624	int rc;
	8625	size_t wsize;
	8626	char *ptr;
	8627	#ifdef _WIN32
	8628	DWORD len, w2;
	8629	#define DO_WRITE(rc, fd, ptr, w2, len) rc = WriteFile(fd, ptr, w2, &len, NULL)
	8630	#else
	8631	ssize_t len;
	8632	size_t w2;
	8633	#define DO_WRITE(rc, fd, ptr, w2, len) len = write(fd, ptr, w2); rc = (len >= 0)
	8634	#endif
	8635
	8636	/* Do the lock/unlock of the reader mutex before starting the
	8637	* write txn. Otherwise other read txns could block writers.
	8638	*/
	8639	rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
	8640	if (rc)
	8641	return rc;
	8642
	8643	if (env->me_txns) {
	8644	/* We must start the actual read txn after blocking writers */
	8645	mdb_txn_reset0(txn, "reset-stage1");
	8646
	8647	/* Temporarily block writers until we snapshot the meta pages */
	8648	LOCK_MUTEX_W(env);
	8649
	8650	rc = mdb_txn_renew0(txn);
	8651	if (rc) {
	8652	UNLOCK_MUTEX_W(env);
	8653	goto leave;
	8654	}
	8655	}
	8656
	8657	wsize = env->me_psize * 2;
	8658	ptr = env->me_map;
	8659	w2 = wsize;
	8660	while (w2 > 0) {
	8661	DO_WRITE(rc, fd, ptr, w2, len);
	8662	if (!rc) {
	8663	rc = ErrCode();
	8664	break;
	8665	} else if (len > 0) {
	8666	rc = MDB_SUCCESS;
	8667	ptr += len;
	8668	w2 -= len;
	8669	continue;
	8670	} else {
	8671	/* Non-blocking or async handles are not supported */
	8672	rc = EIO;
	8673	break;
	8674	}
	8675	}
	8676	if (env->me_txns)
	8677	UNLOCK_MUTEX_W(env);
	8678
	8679	if (rc)
	8680	goto leave;
	8681
	8682	w2 = txn->mt_next_pgno * env->me_psize;
	8683	#ifdef WIN32
	8684	{
	8685	LARGE_INTEGER fsize;
	8686	GetFileSizeEx(env->me_fd, &fsize);
	8687	if (w2 > fsize.QuadPart)
	8688	w2 = fsize.QuadPart;
	8689	}
	8690	#else
	8691	{
	8692	struct stat st;
	8693	fstat(env->me_fd, &st);
	8694	if (w2 > (size_t)st.st_size)
	8695	w2 = st.st_size;
	8696	}
	8697	#endif
	8698	wsize = w2 - wsize;
	8699	while (wsize > 0) {
	8700	if (wsize > MAX_WRITE)
	8701	w2 = MAX_WRITE;
	8702	else
	8703	w2 = wsize;
	8704	DO_WRITE(rc, fd, ptr, w2, len);
	8705	if (!rc) {
	8706	rc = ErrCode();
	8707	break;
	8708	} else if (len > 0) {
	8709	rc = MDB_SUCCESS;
	8710	ptr += len;
	8711	wsize -= len;
	8712	continue;
	8713	} else {
	8714	rc = EIO;
	8715	break;
	8716	}
	8717	}
	8718
	8719	leave:
	8720	mdb_txn_abort(txn);
	8721	return rc;
	8722	}
	8723
	8724	int ESECT
	8725	mdb_env_copyfd2(MDB_env *env, HANDLE fd, unsigned int flags)
	8726	{
	8727	if (flags & MDB_CP_COMPACT)
	8728	return mdb_env_copyfd1(env, fd);
	8729	else
	8730	return mdb_env_copyfd0(env, fd);
	8731	}
	8732
	8733	int ESECT
	8734	mdb_env_copyfd(MDB_env *env, HANDLE fd)
	8735	{
	8736	return mdb_env_copyfd2(env, fd, 0);
	8737	}
	8738
	8739	int ESECT
	8740	mdb_env_copy2(MDB_env env, const char path, unsigned int flags)
	8741	{
	8742	int rc, len;
	8743	char *lpath;
	8744	HANDLE newfd = INVALID_HANDLE_VALUE;
	8745
	8746	if (env->me_flags & MDB_NOSUBDIR) {
	8747	lpath = (char *)path;
	8748	} else {
	8749	len = strlen(path);
	8750	len += sizeof(DATANAME);
	8751	lpath = malloc(len);
	8752	if (!lpath)
	8753	return ENOMEM;
	8754	sprintf(lpath, "%s" DATANAME, path);
	8755	}
	8756
	8757	/* The destination path must exist, but the destination file must not.
	8758	* We don't want the OS to cache the writes, since the source data is
	8759	* already in the OS cache.
	8760	*/
	8761	#ifdef _WIN32
	8762	newfd = CreateFile(lpath, GENERIC_WRITE, 0, NULL, CREATE_NEW,
	8763	FILE_FLAG_NO_BUFFERING\|FILE_FLAG_WRITE_THROUGH, NULL);
	8764	#else
	8765	newfd = open(lpath, O_WRONLY\|O_CREAT\|O_EXCL, 0666);
	8766	#endif
	8767	if (newfd == INVALID_HANDLE_VALUE) {
	8768	rc = ErrCode();
	8769	goto leave;
	8770	}
	8771
	8772	if (env->me_psize >= env->me_os_psize) {
	8773	#ifdef O_DIRECT
	8774	/* Set O_DIRECT if the file system supports it */
	8775	if ((rc = fcntl(newfd, F_GETFL)) != -1)
	8776	(void) fcntl(newfd, F_SETFL, rc \| O_DIRECT);
	8777	#endif
	8778	#ifdef F_NOCACHE /* __APPLE__ */
	8779	rc = fcntl(newfd, F_NOCACHE, 1);
	8780	if (rc) {
	8781	rc = ErrCode();
	8782	goto leave;
	8783	}
	8784	#endif
	8785	}
	8786
	8787	rc = mdb_env_copyfd2(env, newfd, flags);
	8788
	8789	leave:
	8790	if (!(env->me_flags & MDB_NOSUBDIR))
	8791	free(lpath);
	8792	if (newfd != INVALID_HANDLE_VALUE)
	8793	if (close(newfd) < 0 && rc == MDB_SUCCESS)
	8794	rc = ErrCode();
	8795
	8796	return rc;
	8797	}
	8798
	8799	int ESECT
	8800	mdb_env_copy(MDB_env env, const char path)
	8801	{
	8802	return mdb_env_copy2(env, path, 0);
	8803	}
	8804
	8805	int ESECT
7934	8806	mdb_env_set_flags(MDB_env *env, unsigned int flag, int onoff)
7935	8807	{
7936	8808	if ((flag & CHANGEABLE) != flag)

7942	8814	return MDB_SUCCESS;
7943	8815	}
7944	8816
7945		int
	8817	int ESECT
7946	8818	mdb_env_get_flags(MDB_env env, unsigned int arg)
7947	8819	{
7948	8820	if (!env \|\| !arg)

7952	8824	return MDB_SUCCESS;
7953	8825	}
7954	8826
7955		int
	8827	int ESECT
7956	8828	mdb_env_set_userctx(MDB_env env, void ctx)
7957	8829	{
7958	8830	if (!env)

7961	8833	return MDB_SUCCESS;
7962	8834	}
7963	8835
7964		void *
	8836	void * ESECT
7965	8837	mdb_env_get_userctx(MDB_env *env)
7966	8838	{
7967	8839	return env ? env->me_userctx : NULL;
7968	8840	}
7969	8841
7970		int
	8842	int ESECT
7971	8843	mdb_env_set_assert(MDB_env env, MDB_assert_func func)
7972	8844	{
7973	8845	if (!env)

7978	8850	return MDB_SUCCESS;
7979	8851	}
7980	8852
7981		int
	8853	int ESECT
7982	8854	mdb_env_get_path(MDB_env env, const char *arg)
7983	8855	{
7984	8856	if (!env \|\| !arg)

7988	8860	return MDB_SUCCESS;
7989	8861	}
7990	8862
7991		int
	8863	int ESECT
7992	8864	mdb_env_get_fd(MDB_env env, mdb_filehandle_t arg)
7993	8865	{
7994	8866	if (!env \|\| !arg)

8004	8876	* @param[out] arg the address of an #MDB_stat structure to receive the stats.
8005	8877	* @return 0, this function always succeeds.
8006	8878	*/
8007		static int
	8879	static int ESECT
8008	8880	mdb_stat0(MDB_env env, MDB_db db, MDB_stat *arg)
8009	8881	{
8010	8882	arg->ms_psize = env->me_psize;

8016	8888
8017	8889	return MDB_SUCCESS;
8018	8890	}
8019		int
	8891
	8892	int ESECT
8020	8893	mdb_env_stat(MDB_env env, MDB_stat arg)
8021	8894	{
8022	8895	int toggle;

8029	8902	return mdb_stat0(env, &env->me_metas[toggle]->mm_dbs[MAIN_DBI], arg);
8030	8903	}
8031	8904
8032		int
	8905	int ESECT
8033	8906	mdb_env_info(MDB_env env, MDB_envinfo arg)
8034	8907	{
8035	8908	int toggle;

8038	8911	return EINVAL;
8039	8912
8040	8913	toggle = mdb_env_pick_meta(env);
8041		arg->me_mapaddr = (env->me_flags & MDB_FIXEDMAP) ? env->me_map : 0;
	8914	arg->me_mapaddr = env->me_metas[toggle]->mm_address;
8042	8915	arg->me_mapsize = env->me_mapsize;
8043	8916	arg->me_maxreaders = env->me_maxreaders;
8044	8917

8080	8953	MDB_val key, data;
8081	8954	MDB_dbi i;
8082	8955	MDB_cursor mc;
	8956	MDB_db dummy;
8083	8957	int rc, dbflag, exact;
8084		unsigned int unused = 0;
	8958	unsigned int unused = 0, seq;
8085	8959	size_t len;
8086	8960
8087	8961	if (txn->mt_dbxs[FREE_DBI].md_cmp == NULL) {

8149	9023	return MDB_INCOMPATIBLE;
8150	9024	} else if (rc == MDB_NOTFOUND && (flags & MDB_CREATE)) {
8151	9025	/* Create if requested */
8152		MDB_db dummy;
8153	9026	data.mv_size = sizeof(MDB_db);
8154	9027	data.mv_data = &dummy;
8155	9028	memset(&dummy, 0, sizeof(dummy));

8166	9039	txn->mt_dbxs[slot].md_name.mv_size = len;
8167	9040	txn->mt_dbxs[slot].md_rel = NULL;
8168	9041	txn->mt_dbflags[slot] = dbflag;
	9042	/* txn-> and env-> are the same in read txns, use
	9043	* tmp variable to avoid undefined assignment
	9044	*/
	9045	seq = ++txn->mt_env->me_dbiseqs[slot];
	9046	txn->mt_dbiseqs[slot] = seq;
	9047
8169	9048	memcpy(&txn->mt_dbs[slot], data.mv_data, sizeof(MDB_db));
8170	9049	*dbi = slot;
8171	9050	mdb_default_cmp(txn, slot);

8179	9058
8180	9059	int mdb_stat(MDB_txn txn, MDB_dbi dbi, MDB_stat arg)
8181	9060	{
8182		if (txn == NULL \|\| arg == NULL \|\| dbi >= txn->mt_numdbs)
	9061	if (!arg \|\| !TXN_DBI_EXIST(txn, dbi))
8183	9062	return EINVAL;
	9063
	9064	if (txn->mt_flags & MDB_TXN_ERROR)
	9065	return MDB_BAD_TXN;
8184	9066
8185	9067	if (txn->mt_dbflags[dbi] & DB_STALE) {
8186	9068	MDB_cursor mc;

8197	9079	if (dbi <= MAIN_DBI \|\| dbi >= env->me_maxdbs)
8198	9080	return;
8199	9081	ptr = env->me_dbxs[dbi].md_name.mv_data;
8200		env->me_dbxs[dbi].md_name.mv_data = NULL;
8201		env->me_dbxs[dbi].md_name.mv_size = 0;
8202		env->me_dbflags[dbi] = 0;
8203		free(ptr);
	9082	/* If there was no name, this was already closed */
	9083	if (ptr) {
	9084	env->me_dbxs[dbi].md_name.mv_data = NULL;
	9085	env->me_dbxs[dbi].md_name.mv_size = 0;
	9086	env->me_dbflags[dbi] = 0;
	9087	env->me_dbiseqs[dbi]++;
	9088	free(ptr);
	9089	}
8204	9090	}
8205	9091
8206	9092	int mdb_dbi_flags(MDB_txn txn, MDB_dbi dbi, unsigned int flags)
8207	9093	{
8208	9094	/* We could return the flags for the FREE_DBI too but what's the point? */
8209		if (txn == NULL \|\| dbi < MAIN_DBI \|\| dbi >= txn->mt_numdbs)
	9095	if (dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8210	9096	return EINVAL;
8211	9097	*flags = txn->mt_dbs[dbi].md_flags & PERSISTENT_FLAGS;
8212	9098	return MDB_SUCCESS;

8246	9132	memcpy(&pg, NODEDATA(ni), sizeof(pg));
8247	9133	rc = mdb_page_get(txn, pg, &omp, NULL);
8248	9134	if (rc != 0)
8249		return rc;
	9135	goto done;
8250	9136	mdb_cassert(mc, IS_OVERFLOW(omp));
8251	9137	rc = mdb_midl_append_range(&txn->mt_free_pgs,
8252	9138	pg, omp->mp_pages);
8253	9139	if (rc)
8254		return rc;
	9140	goto done;
8255	9141	} else if (subs && (ni->mn_flags & F_SUBDATA)) {
8256	9142	mdb_xcursor_init1(mc, ni);
8257	9143	rc = mdb_drop0(&mc->mc_xcursor->mx_cursor, 0);
8258	9144	if (rc)
8259		return rc;
	9145	goto done;
8260	9146	}
8261	9147	}
8262	9148	} else {
8263	9149	if ((rc = mdb_midl_need(&txn->mt_free_pgs, n)) != 0)
8264		return rc;
	9150	goto done;
8265	9151	for (i=0; i<n; i++) {
8266	9152	pgno_t pg;
8267	9153	ni = NODEPTR(mp, i);

8275	9161	mc->mc_ki[mc->mc_top] = i;
8276	9162	rc = mdb_cursor_sibling(mc, 1);
8277	9163	if (rc) {
	9164	if (rc != MDB_NOTFOUND)
	9165	goto done;
8278	9166	/* no more siblings, go back to beginning
8279	9167	* of previous level.
8280	9168	*/

8288	9176	}
8289	9177	/* free it */
8290	9178	rc = mdb_midl_append(&txn->mt_free_pgs, mc->mc_db->md_root);
	9179	done:
	9180	if (rc)
	9181	txn->mt_flags \|= MDB_TXN_ERROR;
8291	9182	} else if (rc == MDB_NOTFOUND) {
8292	9183	rc = MDB_SUCCESS;
8293	9184	}

8299	9190	MDB_cursor mc, m2;
8300	9191	int rc;
8301	9192
8302		if (!txn \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| (unsigned)del > 1 \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	9193	if ((unsigned)del > 1 \|\| dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8303	9194	return EINVAL;
8304	9195
8305	9196	if (F_ISSET(txn->mt_flags, MDB_TXN_RDONLY))
8306	9197	return EACCES;
	9198
	9199	if (dbi > MAIN_DBI && TXN_DBI_CHANGED(txn, dbi))
	9200	return MDB_BAD_DBI;
8307	9201
8308	9202	rc = mdb_cursor_open(txn, dbi, &mc);
8309	9203	if (rc)

8318	9212
8319	9213	/* Can't delete the main DB */
8320	9214	if (del && dbi > MAIN_DBI) {
8321		rc = mdb_del(txn, MAIN_DBI, &mc->mc_dbx->md_name, NULL);
	9215	rc = mdb_del0(txn, MAIN_DBI, &mc->mc_dbx->md_name, NULL, 0);
8322	9216	if (!rc) {
8323	9217	txn->mt_dbflags[dbi] = DB_STALE;
8324	9218	mdb_dbi_close(txn->mt_env, dbi);
	9219	} else {
	9220	txn->mt_flags \|= MDB_TXN_ERROR;
8325	9221	}
8326	9222	} else {
8327	9223	/* reset the DB record, mark it dirty */

8342	9238
8343	9239	int mdb_set_compare(MDB_txn txn, MDB_dbi dbi, MDB_cmp_func cmp)
8344	9240	{
8345		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	9241	if (dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8346	9242	return EINVAL;
8347	9243
8348	9244	txn->mt_dbxs[dbi].md_cmp = cmp;

8351	9247
8352	9248	int mdb_set_dupsort(MDB_txn txn, MDB_dbi dbi, MDB_cmp_func cmp)
8353	9249	{
8354		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	9250	if (dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8355	9251	return EINVAL;
8356	9252
8357	9253	txn->mt_dbxs[dbi].md_dcmp = cmp;

8360	9256
8361	9257	int mdb_set_relfunc(MDB_txn txn, MDB_dbi dbi, MDB_rel_func rel)
8362	9258	{
8363		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	9259	if (dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8364	9260	return EINVAL;
8365	9261
8366	9262	txn->mt_dbxs[dbi].md_rel = rel;

8369	9265
8370	9266	int mdb_set_relctx(MDB_txn txn, MDB_dbi dbi, void ctx)
8371	9267	{
8372		if (txn == NULL \|\| !dbi \|\| dbi >= txn->mt_numdbs \|\| !(txn->mt_dbflags[dbi] & DB_VALID))
	9268	if (dbi == FREE_DBI \|\| !TXN_DBI_EXIST(txn, dbi))
8373	9269	return EINVAL;
8374	9270
8375	9271	txn->mt_dbxs[dbi].md_relctx = ctx;
8376	9272	return MDB_SUCCESS;
8377	9273	}
8378	9274
8379		int mdb_env_get_maxkeysize(MDB_env *env)
	9275	int ESECT
	9276	mdb_env_get_maxkeysize(MDB_env *env)
8380	9277	{
8381	9278	return ENV_MAXKEY(env);
8382	9279	}
8383	9280
8384		int mdb_reader_list(MDB_env env, MDB_msg_func func, void *ctx)
	9281	int ESECT
	9282	mdb_reader_list(MDB_env env, MDB_msg_func func, void *ctx)
8385	9283	{
8386	9284	unsigned int i, rdrs;
8387	9285	MDB_reader *mr;

8421	9319	/** Insert pid into list if not already present.
8422	9320	* return -1 if already present.
8423	9321	*/
8424		static int mdb_pid_insert(MDB_PID_T *ids, MDB_PID_T pid)
	9322	static int ESECT
	9323	mdb_pid_insert(MDB_PID_T *ids, MDB_PID_T pid)
8425	9324	{
8426	9325	/* binary search of pid in list */
8427	9326	unsigned base = 0;

8457	9356	return 0;
8458	9357	}
8459	9358
8460		int mdb_reader_check(MDB_env env, int dead)
	9359	int ESECT
	9360	mdb_reader_check(MDB_env env, int dead)
8461	9361	{
8462	9362	unsigned int i, j, rdrs;
8463	9363	MDB_reader *mr;

+15

-2

libraries/liblmdb/mdb_copy.1 less more

0		.TH MDB_COPY 1 "2012/12/12" "LMDB 0.9.5"
1		.\" Copyright 2012 Howard Chu, Symas Corp. All Rights Reserved.
	0	.TH MDB_COPY 1 "2014/06/20" "LMDB 0.9.14"
	1	.\" Copyright 2012-2014 Howard Chu, Symas Corp. All Rights Reserved.
2	2	.\" Copying restrictions apply. See COPYRIGHT/LICENSE.
3	3	.SH NAME
4	4	mdb_copy \- LMDB environment copy tool
5	5	.SH SYNOPSIS
6	6	.B mdb_copy
	7	[\c
	8	.BR \-V ]
	9	[\c
	10	.BR \-c ]
7	11	[\c
8	12	.BR \-n ]
9	13	.B srcpath

23	27	written to stdout.
24	28
25	29	.SH OPTIONS
	30	.TP
	31	.BR \-V
	32	Write the library version number to the standard output, and exit.
	33	.TP
	34	.BR \-c
	35	Compact while copying. Only current data pages will be copied; freed
	36	or unused pages will be omitted from the copy. This option will
	37	slow down the backup process as it is more CPU-intensive.
	38	.TP
26	39	.BR \-n
27	40	Open LDMB environment(s) which do not use subdirectories.
28	41

+11

-5

libraries/liblmdb/mdb_copy.c less more

32	32	MDB_env *env;
33	33	const char progname = argv[0], act;
34	34	unsigned flags = MDB_RDONLY;
	35	unsigned cpflags = 0;
35	36
36	37	for (; argc > 1 && argv[1][0] == '-'; argc--, argv++) {
37	38	if (argv[1][1] == 'n' && argv[1][2] == '\0')
38	39	flags \|= MDB_NOSUBDIR;
39		else
	40	else if (argv[1][1] == 'c' && argv[1][2] == '\0')
	41	cpflags \|= MDB_CP_COMPACT;
	42	else if (argv[1][1] == 'V' && argv[1][2] == '\0') {
	43	printf("%s\n", MDB_VERSION_STRING);
	44	exit(0);
	45	} else
40	46	argc = 0;
41	47	}
42	48
43	49	if (argc<2 \|\| argc>3) {
44		fprintf(stderr, "usage: %s [-n] srcpath [dstpath]\n", progname);
	50	fprintf(stderr, "usage: %s [-V] [-c] [-n] srcpath [dstpath]\n", progname);
45	51	exit(EXIT_FAILURE);
46	52	}
47	53

57	63	act = "opening environment";
58	64	rc = mdb_env_create(&env);
59	65	if (rc == MDB_SUCCESS) {
60		rc = mdb_env_open(env, argv[1], flags, 0);
	66	rc = mdb_env_open(env, argv[1], flags, 0664);
61	67	}
62	68	if (rc == MDB_SUCCESS) {
63	69	act = "copying";
64	70	if (argc == 2)
65		rc = mdb_env_copyfd(env, MDB_STDOUT);
	71	rc = mdb_env_copyfd2(env, MDB_STDOUT, cpflags);
66	72	else
67		rc = mdb_env_copy(env, argv[2]);
	73	rc = mdb_env_copy2(env, argv[2], cpflags);
68	74	}
69	75	if (rc)
70	76	fprintf(stderr, "%s: %s failed, error %d (%s)\n",

+75

-0

libraries/liblmdb/mdb_dump.1 less more

	0	.TH MDB_DUMP 1 "2014/06/20" "LMDB 0.9.14"
	1	.\" Copyright 2014 Howard Chu, Symas Corp. All Rights Reserved.
	2	.\" Copying restrictions apply. See COPYRIGHT/LICENSE.
	3	.SH NAME
	4	mdb_dump \- LMDB environment export tool
	5	.SH SYNOPSIS
	6	.B mdb_dump
	7	.BR \ envpath
	8	[\c
	9	.BR \-V ]
	10	[\c
	11	.BI \-f \ file\fR]
	12	[\c
	13	.BR \-l ]
	14	[\c
	15	.BR \-n ]
	16	[\c
	17	.BR \-p ]
	18	[\c
	19	.BR \-a \ \|
	20	.BI \-s \ subdb\fR]
	21	.SH DESCRIPTION
	22	The
	23	.B mdb_dump
	24	utility reads a database and writes its contents to the
	25	standard output using a portable flat-text format
	26	understood by the
	27	.BR mdb_load (1)
	28	utility.
	29	.SH OPTIONS
	30	.TP
	31	.BR \-V
	32	Write the library version number to the standard output, and exit.
	33	.TP
	34	.BR \-f \ file
	35	Write to the specified file instead of to the standard output.
	36	.TP
	37	.BR \-l
	38	List the databases stored in the environment. Just the
	39	names will be listed, no data will be output.
	40	.TP
	41	.BR \-n
	42	Dump an LMDB database which does not use subdirectories.
	43	.TP
	44	.BR \-p
	45	If characters in either the key or data items are printing characters (as
	46	defined by isprint(3)), output them directly. This option permits users to
	47	use standard text editors and tools to modify the contents of databases.
	48
	49	Note: different systems may have different notions about what characters
	50	are considered printing characters, and databases dumped in this manner may
	51	be less portable to external systems.
	52	.TP
	53	.BR \-a
	54	Dump all of the subdatabases in the environment.
	55	.TP
	56	.BR \-s \ subdb
	57	Dump a specific subdatabase. If no database is specified, only the main database is dumped.
	58	.SH DIAGNOSTICS
	59	Exit status is zero if no errors occur.
	60	Errors result in a non-zero exit status and
	61	a diagnostic message being written to standard error.
	62
	63	Dumping and reloading databases that use user-defined comparison functions
	64	will result in new databases that use the default comparison functions.
	65	\fBIn this case it is quite likely that the reloaded database will be
	66	damaged beyond repair permitting neither record storage nor retrieval.\fP
	67
	68	The only available workaround is to modify the source for the
	69	.BR mdb_load (1)
	70	utility to load the database using the correct comparison functions.
	71	.SH "SEE ALSO"
	72	.BR mdb_load (1)
	73	.SH AUTHOR
	74	Howard Chu of Symas Corporation <http://www.symas.com>

+317

-0

libraries/liblmdb/mdb_dump.c less more

	0	/* mdb_dump.c - memory-mapped database dump tool */
	1	/*
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted only as authorized by the OpenLDAP
	7	* Public License.
	8	*
	9	* A copy of this license is available in the file LICENSE in the
	10	* top-level directory of the distribution or, alternatively, at
	11	* <http://www.OpenLDAP.org/license.html>.
	12	*/
	13	#include <stdio.h>
	14	#include <errno.h>
	15	#include <stdlib.h>
	16	#include <string.h>
	17	#include <ctype.h>
	18	#include <unistd.h>
	19	#include <signal.h>
	20	#include "lmdb.h"
	21
	22	#ifdef _WIN32
	23	#define Z "I"
	24	#else
	25	#define Z "z"
	26	#endif
	27
	28	#define PRINT 1
	29	static int mode;
	30
	31	typedef struct flagbit {
	32	int bit;
	33	char *name;
	34	} flagbit;
	35
	36	flagbit dbflags[] = {
	37	{ MDB_REVERSEKEY, "reversekey" },
	38	{ MDB_DUPSORT, "dupsort" },
	39	{ MDB_INTEGERKEY, "integerkey" },
	40	{ MDB_DUPFIXED, "dupfixed" },
	41	{ MDB_INTEGERDUP, "integerdup" },
	42	{ MDB_REVERSEDUP, "reversedup" },
	43	{ 0, NULL }
	44	};
	45
	46	static volatile sig_atomic_t gotsig;
	47
	48	static void dumpsig( int sig )
	49	{
	50	gotsig=1;
	51	}
	52
	53	static const char hexc[] = "0123456789abcdef";
	54
	55	static void hex(unsigned char c)
	56	{
	57	putchar(hexc[c >> 4]);
	58	putchar(hexc[c & 0xf]);
	59	}
	60
	61	static void text(MDB_val *v)
	62	{
	63	unsigned char c, end;
	64
	65	putchar(' ');
	66	c = v->mv_data;
	67	end = c + v->mv_size;
	68	while (c < end) {
	69	if (isprint(*c)) {
	70	putchar(*c);
	71	} else {
	72	putchar('\\');
	73	hex(*c);
	74	}
	75	c++;
	76	}
	77	putchar('\n');
	78	}
	79
	80	static void byte(MDB_val *v)
	81	{
	82	unsigned char c, end;
	83
	84	putchar(' ');
	85	c = v->mv_data;
	86	end = c + v->mv_size;
	87	while (c < end) {
	88	hex(*c++);
	89	}
	90	putchar('\n');
	91	}
	92
	93	/* Dump in BDB-compatible format */
	94	static int dumpit(MDB_txn txn, MDB_dbi dbi, char name)
	95	{
	96	MDB_cursor *mc;
	97	MDB_stat ms;
	98	MDB_val key, data;
	99	MDB_envinfo info;
	100	unsigned int flags;
	101	int rc, i;
	102
	103	rc = mdb_dbi_flags(txn, dbi, &flags);
	104	if (rc) return rc;
	105
	106	rc = mdb_stat(txn, dbi, &ms);
	107	if (rc) return rc;
	108
	109	rc = mdb_env_info(mdb_txn_env(txn), &info);
	110	if (rc) return rc;
	111
	112	printf("VERSION=3\n");
	113	printf("format=%s\n", mode & PRINT ? "print" : "bytevalue");
	114	if (name)
	115	printf("database=%s\n", name);
	116	printf("type=btree\n");
	117	printf("mapsize=%" Z "u\n", info.me_mapsize);
	118	if (info.me_mapaddr)
	119	printf("mapaddr=%p\n", info.me_mapaddr);
	120	printf("maxreaders=%u\n", info.me_maxreaders);
	121
	122	if (flags & MDB_DUPSORT)
	123	printf("duplicates=1\n");
	124
	125	for (i=0; dbflags[i].bit; i++)
	126	if (flags & dbflags[i].bit)
	127	printf("%s=1\n", dbflags[i].name);
	128
	129	printf("db_pagesize=%d\n", ms.ms_psize);
	130	printf("HEADER=END\n");
	131
	132	rc = mdb_cursor_open(txn, dbi, &mc);
	133	if (rc) return rc;
	134
	135	while ((rc = mdb_cursor_get(mc, &key, &data, MDB_NEXT) == MDB_SUCCESS)) {
	136	if (gotsig) {
	137	rc = EINTR;
	138	break;
	139	}
	140	if (mode & PRINT) {
	141	text(&key);
	142	text(&data);
	143	} else {
	144	byte(&key);
	145	byte(&data);
	146	}
	147	}
	148	printf("DATA=END\n");
	149	if (rc == MDB_NOTFOUND)
	150	rc = MDB_SUCCESS;
	151
	152	return rc;
	153	}
	154
	155	static void usage(char *prog)
	156	{
	157	fprintf(stderr, "usage: %s dbpath [-V] [-f output] [-l] [-n] [-p] [-a\|-s subdb]\n", prog);
	158	exit(EXIT_FAILURE);
	159	}
	160
	161	int main(int argc, char *argv[])
	162	{
	163	int i, rc;
	164	MDB_env *env;
	165	MDB_txn *txn;
	166	MDB_dbi dbi;
	167	char *prog = argv[0];
	168	char *envname;
	169	char *subname = NULL;
	170	int alldbs = 0, envflags = 0, list = 0;
	171
	172	if (argc < 2) {
	173	usage(prog);
	174	}
	175
	176	/* -a: dump main DB and all subDBs
	177	* -s: dump only the named subDB
	178	* -n: use NOSUBDIR flag on env_open
	179	* -p: use printable characters
	180	* -f: write to file instead of stdout
	181	* -V: print version and exit
	182	* (default) dump only the main DB
	183	*/
	184	while ((i = getopt(argc, argv, "af:lnps:V")) != EOF) {
	185	switch(i) {
	186	case 'V':
	187	printf("%s\n", MDB_VERSION_STRING);
	188	exit(0);
	189	break;
	190	case 'l':
	191	list = 1;
	192	/FALLTHROUGH/;
	193	case 'a':
	194	if (subname)
	195	usage(prog);
	196	alldbs++;
	197	break;
	198	case 'f':
	199	if (freopen(optarg, "w", stdout) == NULL) {
	200	fprintf(stderr, "%s: %s: reopen: %s\n",
	201	prog, optarg, strerror(errno));
	202	exit(EXIT_FAILURE);
	203	}
	204	break;
	205	case 'n':
	206	envflags \|= MDB_NOSUBDIR;
	207	break;
	208	case 'p':
	209	mode \|= PRINT;
	210	break;
	211	case 's':
	212	if (alldbs)
	213	usage(prog);
	214	subname = optarg;
	215	break;
	216	default:
	217	usage(prog);
	218	}
	219	}
	220
	221	if (optind != argc - 1)
	222	usage(prog);
	223
	224	#ifdef SIGPIPE
	225	signal(SIGPIPE, dumpsig);
	226	#endif
	227	#ifdef SIGHUP
	228	signal(SIGHUP, dumpsig);
	229	#endif
	230	signal(SIGINT, dumpsig);
	231	signal(SIGTERM, dumpsig);
	232
	233	envname = argv[optind];
	234	rc = mdb_env_create(&env);
	235	if (rc) {
	236	fprintf(stderr, "mdb_env_create failed, error %d %s\n", rc, mdb_strerror(rc));
	237	return EXIT_FAILURE;
	238	}
	239
	240	if (alldbs \|\| subname) {
	241	mdb_env_set_maxdbs(env, 2);
	242	}
	243
	244	rc = mdb_env_open(env, envname, envflags \| MDB_RDONLY, 0664);
	245	if (rc) {
	246	fprintf(stderr, "mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
	247	goto env_close;
	248	}
	249
	250	rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
	251	if (rc) {
	252	fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
	253	goto env_close;
	254	}
	255
	256	rc = mdb_open(txn, subname, 0, &dbi);
	257	if (rc) {
	258	fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
	259	goto txn_abort;
	260	}
	261
	262	if (alldbs) {
	263	MDB_cursor *cursor;
	264	MDB_val key;
	265	int count = 0;
	266
	267	rc = mdb_cursor_open(txn, dbi, &cursor);
	268	if (rc) {
	269	fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
	270	goto txn_abort;
	271	}
	272	while ((rc = mdb_cursor_get(cursor, &key, NULL, MDB_NEXT_NODUP)) == 0) {
	273	char *str;
	274	MDB_dbi db2;
	275	if (memchr(key.mv_data, '\0', key.mv_size))
	276	continue;
	277	count++;
	278	str = malloc(key.mv_size+1);
	279	memcpy(str, key.mv_data, key.mv_size);
	280	str[key.mv_size] = '\0';
	281	rc = mdb_open(txn, str, 0, &db2);
	282	if (rc == MDB_SUCCESS) {
	283	if (list) {
	284	printf("%s\n", str);
	285	list++;
	286	} else {
	287	rc = dumpit(txn, db2, str);
	288	if (rc)
	289	break;
	290	}
	291	mdb_close(env, db2);
	292	}
	293	free(str);
	294	if (rc) continue;
	295	}
	296	mdb_cursor_close(cursor);
	297	if (!count) {
	298	fprintf(stderr, "%s: %s does not contain multiple databases\n", prog, envname);
	299	rc = MDB_NOTFOUND;
	300	} else if (rc == MDB_NOTFOUND) {
	301	rc = MDB_SUCCESS;
	302	}
	303	} else {
	304	rc = dumpit(txn, dbi, subname);
	305	}
	306	if (rc && rc != MDB_NOTFOUND)
	307	fprintf(stderr, "%s: %s: %s\n", prog, envname, mdb_strerror(rc));
	308
	309	mdb_close(env, dbi);
	310	txn_abort:
	311	mdb_txn_abort(txn);
	312	env_close:
	313	mdb_env_close(env);
	314
	315	return rc ? EXIT_FAILURE : EXIT_SUCCESS;
	316	}

+77

-0

libraries/liblmdb/mdb_load.1 less more

	0	.TH MDB_LOAD 1 "2014/06/20" "LMDB 0.9.14"
	1	.\" Copyright 2014 Howard Chu, Symas Corp. All Rights Reserved.
	2	.\" Copying restrictions apply. See COPYRIGHT/LICENSE.
	3	.SH NAME
	4	mdb_load \- LMDB environment import tool
	5	.SH SYNOPSIS
	6	.B mdb_load
	7	.BR \ envpath
	8	[\c
	9	.BR \-V ]
	10	[\c
	11	.BI \-f \ file\fR]
	12	[\c
	13	.BR \-n ]
	14	[\c
	15	.BI \-s \ subdb\fR]
	16	[\c
	17	.BR \-N ]
	18	[\c
	19	.BR \-T ]
	20	.SH DESCRIPTION
	21	The
	22	.B mdb_load
	23	utility reads from the standard input and loads it into the
	24	LMDB environment
	25	.BR envpath .
	26
	27	The input to
	28	.B mdb_load
	29	must be in the output format specified by the
	30	.BR mdb_dump (1)
	31	utility or as specified by the
	32	.B -T
	33	option below.
	34	.SH OPTIONS
	35	.TP
	36	.BR \-V
	37	Write the library version number to the standard output, and exit.
	38	.TP
	39	.BR \-f \ file
	40	Read from the specified file instead of from the standard input.
	41	.TP
	42	.BR \-n
	43	Load an LMDB database which does not use subdirectories.
	44	.TP
	45	.BR \-s \ subdb
	46	Load a specific subdatabase. If no database is specified, data is loaded into the main database.
	47	.TP
	48	.BR \-N
	49	Don't overwrite existing records when loading into an already existing database; just skip them.
	50	.TP
	51	.BR \-T
	52	Load data from simple text files. The input must be paired lines of text, where the first
	53	line of the pair is the key item, and the second line of the pair is its corresponding
	54	data item.
	55
	56	A simple escape mechanism, where newline and backslash (\\) characters are special, is
	57	applied to the text input. Newline characters are interpreted as record separators.
	58	Backslash characters in the text will be interpreted in one of two ways: If the backslash
	59	character precedes another backslash character, the pair will be interpreted as a literal
	60	backslash. If the backslash character precedes any other character, the two characters
	61	following the backslash will be interpreted as a hexadecimal specification of a single
	62	character; for example, \\0a is a newline character in the ASCII character set.
	63
	64	For this reason, any backslash or newline characters that naturally occur in the text
	65	input must be escaped to avoid misinterpretation by
	66	.BR mdb_load .
	67
	68	.SH DIAGNOSTICS
	69	Exit status is zero if no errors occur.
	70	Errors result in a non-zero exit status and
	71	a diagnostic message being written to standard error.
	72
	73	.SH "SEE ALSO"
	74	.BR mdb_dump (1)
	75	.SH AUTHOR
	76	Howard Chu of Symas Corporation <http://www.symas.com>

+452

-0

libraries/liblmdb/mdb_load.c less more

	0	/* mdb_load.c - memory-mapped database load tool */
	1	/*
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted only as authorized by the OpenLDAP
	7	* Public License.
	8	*
	9	* A copy of this license is available in the file LICENSE in the
	10	* top-level directory of the distribution or, alternatively, at
	11	* <http://www.OpenLDAP.org/license.html>.
	12	*/
	13	#include <stdio.h>
	14	#include <stdlib.h>
	15	#include <errno.h>
	16	#include <string.h>
	17	#include <ctype.h>
	18	#include <unistd.h>
	19	#include "lmdb.h"
	20
	21	#define PRINT 1
	22	#define NOHDR 2
	23	static int mode;
	24
	25	static char *subname = NULL;
	26
	27	static size_t lineno;
	28	static int version;
	29
	30	static int flags;
	31
	32	static char *prog;
	33
	34	static int Eof;
	35
	36	static MDB_envinfo info;
	37
	38	static MDB_val kbuf, dbuf;
	39
	40	#ifdef _WIN32
	41	#define Z "I"
	42	#else
	43	#define Z "z"
	44	#endif
	45
	46	#define STRLENOF(s) (sizeof(s)-1)
	47
	48	typedef struct flagbit {
	49	int bit;
	50	char *name;
	51	int len;
	52	} flagbit;
	53
	54	#define S(s) s, STRLENOF(s)
	55
	56	flagbit dbflags[] = {
	57	{ MDB_REVERSEKEY, S("reversekey") },
	58	{ MDB_DUPSORT, S("dupsort") },
	59	{ MDB_INTEGERKEY, S("integerkey") },
	60	{ MDB_DUPFIXED, S("dupfixed") },
	61	{ MDB_INTEGERDUP, S("integerdup") },
	62	{ MDB_REVERSEDUP, S("reversedup") },
	63	{ 0, NULL, 0 }
	64	};
	65
	66	static void readhdr(void)
	67	{
	68	char *ptr;
	69
	70	while (fgets(dbuf.mv_data, dbuf.mv_size, stdin) != NULL) {
	71	lineno++;
	72	if (!strncmp(dbuf.mv_data, "VERSION=", STRLENOF("VERSION="))) {
	73	version=atoi((char *)dbuf.mv_data+STRLENOF("VERSION="));
	74	if (version > 3) {
	75	fprintf(stderr, "%s: line %" Z "d: unsupported VERSION %d\n",
	76	prog, lineno, version);
	77	exit(EXIT_FAILURE);
	78	}
	79	} else if (!strncmp(dbuf.mv_data, "HEADER=END", STRLENOF("HEADER=END"))) {
	80	break;
	81	} else if (!strncmp(dbuf.mv_data, "format=", STRLENOF("format="))) {
	82	if (!strncmp((char *)dbuf.mv_data+STRLENOF("FORMAT="), "print", STRLENOF("print")))
	83	mode \|= PRINT;
	84	else if (strncmp((char *)dbuf.mv_data+STRLENOF("FORMAT="), "bytevalue", STRLENOF("bytevalue"))) {
	85	fprintf(stderr, "%s: line %" Z "d: unsupported FORMAT %s\n",
	86	prog, lineno, (char *)dbuf.mv_data+STRLENOF("FORMAT="));
	87	exit(EXIT_FAILURE);
	88	}
	89	} else if (!strncmp(dbuf.mv_data, "database=", STRLENOF("database="))) {
	90	ptr = memchr(dbuf.mv_data, '\n', dbuf.mv_size);
	91	if (ptr) *ptr = '\0';
	92	if (subname) free(subname);
	93	subname = strdup((char *)dbuf.mv_data+STRLENOF("database="));
	94	} else if (!strncmp(dbuf.mv_data, "type=", STRLENOF("type="))) {
	95	if (strncmp((char *)dbuf.mv_data+STRLENOF("type="), "btree", STRLENOF("btree"))) {
	96	fprintf(stderr, "%s: line %" Z "d: unsupported type %s\n",
	97	prog, lineno, (char *)dbuf.mv_data+STRLENOF("type="));
	98	exit(EXIT_FAILURE);
	99	}
	100	} else if (!strncmp(dbuf.mv_data, "mapaddr=", STRLENOF("mapaddr="))) {
	101	int i;
	102	ptr = memchr(dbuf.mv_data, '\n', dbuf.mv_size);
	103	if (ptr) *ptr = '\0';
	104	i = sscanf((char *)dbuf.mv_data+STRLENOF("mapaddr="), "%p", &info.me_mapaddr);
	105	if (i != 1) {
	106	fprintf(stderr, "%s: line %" Z "d: invalid mapaddr %s\n",
	107	prog, lineno, (char *)dbuf.mv_data+STRLENOF("mapaddr="));
	108	exit(EXIT_FAILURE);
	109	}
	110	} else if (!strncmp(dbuf.mv_data, "mapsize=", STRLENOF("mapsize="))) {
	111	int i;
	112	ptr = memchr(dbuf.mv_data, '\n', dbuf.mv_size);
	113	if (ptr) *ptr = '\0';
	114	i = sscanf((char *)dbuf.mv_data+STRLENOF("mapsize="), "%" Z "u", &info.me_mapsize);
	115	if (i != 1) {
	116	fprintf(stderr, "%s: line %" Z "d: invalid mapsize %s\n",
	117	prog, lineno, (char *)dbuf.mv_data+STRLENOF("mapsize="));
	118	exit(EXIT_FAILURE);
	119	}
	120	} else if (!strncmp(dbuf.mv_data, "maxreaders=", STRLENOF("maxreaders="))) {
	121	int i;
	122	ptr = memchr(dbuf.mv_data, '\n', dbuf.mv_size);
	123	if (ptr) *ptr = '\0';
	124	i = sscanf((char *)dbuf.mv_data+STRLENOF("maxreaders="), "%u", &info.me_maxreaders);
	125	if (i != 1) {
	126	fprintf(stderr, "%s: line %" Z "d: invalid maxreaders %s\n",
	127	prog, lineno, (char *)dbuf.mv_data+STRLENOF("maxreaders="));
	128	exit(EXIT_FAILURE);
	129	}
	130	} else {
	131	int i;
	132	for (i=0; dbflags[i].bit; i++) {
	133	if (!strncmp(dbuf.mv_data, dbflags[i].name, dbflags[i].len) &&
	134	((char *)dbuf.mv_data)[dbflags[i].len] == '=') {
	135	flags \|= dbflags[i].bit;
	136	break;
	137	}
	138	}
	139	if (!dbflags[i].bit) {
	140	ptr = memchr(dbuf.mv_data, '=', dbuf.mv_size);
	141	if (!ptr) {
	142	fprintf(stderr, "%s: line %" Z "d: unexpected format\n",
	143	prog, lineno);
	144	exit(EXIT_FAILURE);
	145	} else {
	146	*ptr = '\0';
	147	fprintf(stderr, "%s: line %" Z "d: unrecognized keyword ignored: %s\n",
	148	prog, lineno, (char *)dbuf.mv_data);
	149	}
	150	}
	151	}
	152	}
	153	}
	154
	155	static void badend(void)
	156	{
	157	fprintf(stderr, "%s: line %" Z "d: unexpected end of input\n",
	158	prog, lineno);
	159	}
	160
	161	static int unhex(unsigned char *c2)
	162	{
	163	int x, c;
	164	x = *c2++ & 0x4f;
	165	if (x & 0x40)
	166	x -= 55;
	167	c = x << 4;
	168	x = *c2 & 0x4f;
	169	if (x & 0x40)
	170	x -= 55;
	171	c \|= x;
	172	return c;
	173	}
	174
	175	static int readline(MDB_val out, MDB_val buf)
	176	{
	177	unsigned char c1, c2, *end;
	178	size_t len;
	179	int c;
	180
	181	if (!(mode & NOHDR)) {
	182	c = fgetc(stdin);
	183	if (c == EOF) {
	184	Eof = 1;
	185	return EOF;
	186	}
	187	if (c != ' ') {
	188	lineno++;
	189	if (fgets(buf->mv_data, buf->mv_size, stdin) == NULL) {
	190	badend:
	191	Eof = 1;
	192	badend();
	193	return EOF;
	194	}
	195	if (c == 'D' && !strncmp(buf->mv_data, "ATA=END", STRLENOF("ATA=END")))
	196	return EOF;
	197	goto badend;
	198	}
	199	}
	200	if (fgets(buf->mv_data, buf->mv_size, stdin) == NULL) {
	201	Eof = 1;
	202	return EOF;
	203	}
	204	lineno++;
	205
	206	c1 = buf->mv_data;
	207	len = strlen((char *)c1);
	208
	209	/* Is buffer too short? */
	210	while (c1[len-1] != '\n') {
	211	buf->mv_data = realloc(buf->mv_data, buf->mv_size*2);
	212	if (!buf->mv_data) {
	213	Eof = 1;
	214	fprintf(stderr, "%s: line %" Z "d: out of memory, line too long\n",
	215	prog, lineno);
	216	return EOF;
	217	}
	218	c1 = buf->mv_data;
	219	c1 += buf->mv_size;
	220	if (fgets((char *)c1, buf->mv_size, stdin) == NULL) {
	221	Eof = 1;
	222	badend();
	223	return EOF;
	224	}
	225	buf->mv_size *= 2;
	226	len = strlen((char *)c1);
	227	}
	228	c1 = c2 = buf->mv_data;
	229	len = strlen((char *)c1);
	230	c1[--len] = '\0';
	231	end = c1 + len;
	232
	233	if (mode & PRINT) {
	234	while (c2 < end) {
	235	if (*c2 == '\\') {
	236	if (c2[1] == '\\') {
	237	c1++; c2 += 2;
	238	} else {
	239	if (c2+3 > end \|\| !isxdigit(c2[1]) \|\| !isxdigit(c2[2])) {
	240	Eof = 1;
	241	badend();
	242	return EOF;
	243	}
	244	*c1++ = unhex(++c2);
	245	c2 += 2;
	246	}
	247	} else {
	248	c1++; c2++;
	249	}
	250	}
	251	} else {
	252	/* odd length not allowed */
	253	if (len & 1) {
	254	Eof = 1;
	255	badend();
	256	return EOF;
	257	}
	258	while (c2 < end) {
	259	if (!isxdigit(*c2) \|\| !isxdigit(c2[1])) {
	260	Eof = 1;
	261	badend();
	262	return EOF;
	263	}
	264	*c1++ = unhex(c2);
	265	c2 += 2;
	266	}
	267	}
	268	c2 = out->mv_data = buf->mv_data;
	269	out->mv_size = c1 - c2;
	270
	271	return 0;
	272	}
	273
	274	static void usage(void)
	275	{
	276	fprintf(stderr, "usage: %s dbpath [-V] [-f input] [-n] [-s name] [-N] [-T]\n", prog);
	277	exit(EXIT_FAILURE);
	278	}
	279
	280	int main(int argc, char *argv[])
	281	{
	282	int i, rc;
	283	MDB_env *env;
	284	MDB_txn *txn;
	285	MDB_cursor *mc;
	286	MDB_dbi dbi;
	287	char *envname;
	288	int envflags = 0, putflags = 0;
	289	int dohdr = 0;
	290
	291	prog = argv[0];
	292
	293	if (argc < 2) {
	294	usage();
	295	}
	296
	297	/* -f: load file instead of stdin
	298	* -n: use NOSUBDIR flag on env_open
	299	* -s: load into named subDB
	300	* -N: use NOOVERWRITE on puts
	301	* -T: read plaintext
	302	* -V: print version and exit
	303	*/
	304	while ((i = getopt(argc, argv, "f:ns:NTV")) != EOF) {
	305	switch(i) {
	306	case 'V':
	307	printf("%s\n", MDB_VERSION_STRING);
	308	exit(0);
	309	break;
	310	case 'f':
	311	if (freopen(optarg, "r", stdin) == NULL) {
	312	fprintf(stderr, "%s: %s: reopen: %s\n",
	313	prog, optarg, strerror(errno));
	314	exit(EXIT_FAILURE);
	315	}
	316	break;
	317	case 'n':
	318	envflags \|= MDB_NOSUBDIR;
	319	break;
	320	case 's':
	321	subname = strdup(optarg);
	322	break;
	323	case 'N':
	324	putflags = MDB_NOOVERWRITE\|MDB_NODUPDATA;
	325	break;
	326	case 'T':
	327	mode \|= NOHDR;
	328	break;
	329	default:
	330	usage();
	331	}
	332	}
	333
	334	if (optind != argc - 1)
	335	usage();
	336
	337	dbuf.mv_size = 4096;
	338	dbuf.mv_data = malloc(dbuf.mv_size);
	339
	340	if (!(mode & NOHDR))
	341	readhdr();
	342
	343	envname = argv[optind];
	344	rc = mdb_env_create(&env);
	345	if (rc) {
	346	fprintf(stderr, "mdb_env_create failed, error %d %s\n", rc, mdb_strerror(rc));
	347	return EXIT_FAILURE;
	348	}
	349
	350	mdb_env_set_maxdbs(env, 2);
	351
	352	if (info.me_maxreaders)
	353	mdb_env_set_maxreaders(env, info.me_maxreaders);
	354
	355	if (info.me_mapsize)
	356	mdb_env_set_mapsize(env, info.me_mapsize);
	357
	358	if (info.me_mapaddr)
	359	envflags \|= MDB_FIXEDMAP;
	360
	361	rc = mdb_env_open(env, envname, envflags, 0664);
	362	if (rc) {
	363	fprintf(stderr, "mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
	364	goto env_close;
	365	}
	366
	367	kbuf.mv_size = mdb_env_get_maxkeysize(env) * 2 + 2;
	368	kbuf.mv_data = malloc(kbuf.mv_size);
	369
	370	while(!Eof) {
	371	MDB_val key, data;
	372	int batch = 0;
	373	flags = 0;
	374
	375	if (!dohdr) {
	376	dohdr = 1;
	377	} else if (!(mode & NOHDR))
	378	readhdr();
	379
	380	rc = mdb_txn_begin(env, NULL, 0, &txn);
	381	if (rc) {
	382	fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
	383	goto env_close;
	384	}
	385
	386	rc = mdb_open(txn, subname, flags\|MDB_CREATE, &dbi);
	387	if (rc) {
	388	fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
	389	goto txn_abort;
	390	}
	391
	392	rc = mdb_cursor_open(txn, dbi, &mc);
	393	if (rc) {
	394	fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
	395	goto txn_abort;
	396	}
	397
	398	while(1) {
	399	rc = readline(&key, &kbuf);
	400	if (rc == EOF)
	401	break;
	402	if (rc)
	403	goto txn_abort;
	404
	405	rc = readline(&data, &dbuf);
	406	if (rc)
	407	goto txn_abort;
	408
	409	rc = mdb_cursor_put(mc, &key, &data, putflags);
	410	if (rc == MDB_KEYEXIST && putflags)
	411	continue;
	412	if (rc)
	413	goto txn_abort;
	414	batch++;
	415	if (batch == 100) {
	416	rc = mdb_txn_commit(txn);
	417	if (rc) {
	418	fprintf(stderr, "%s: line %" Z "d: txn_commit: %s\n",
	419	prog, lineno, mdb_strerror(rc));
	420	goto env_close;
	421	}
	422	rc = mdb_txn_begin(env, NULL, 0, &txn);
	423	if (rc) {
	424	fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
	425	goto env_close;
	426	}
	427	rc = mdb_cursor_open(txn, dbi, &mc);
	428	if (rc) {
	429	fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
	430	goto txn_abort;
	431	}
	432	batch = 0;
	433	}
	434	}
	435	rc = mdb_txn_commit(txn);
	436	txn = NULL;
	437	if (rc) {
	438	fprintf(stderr, "%s: line %" Z "d: txn_commit: %s\n",
	439	prog, lineno, mdb_strerror(rc));
	440	goto env_close;
	441	}
	442	mdb_dbi_close(env, dbi);
	443	}
	444
	445	txn_abort:
	446	mdb_txn_abort(txn);
	447	env_close:
	448	mdb_env_close(env);
	449
	450	return rc ? EXIT_FAILURE : EXIT_SUCCESS;
	451	}

-2

libraries/liblmdb/mdb_stat.1 less more

0		.TH MDB_STAT 1 "2012/12/12" "LMDB 0.9.5"
1		.\" Copyright 2012 Howard Chu, Symas Corp. All Rights Reserved.
	0	.TH MDB_STAT 1 "2014/06/20" "LMDB 0.9.14"
	1	.\" Copyright 2012-2014 Howard Chu, Symas Corp. All Rights Reserved.
2	2	.\" Copying restrictions apply. See COPYRIGHT/LICENSE.
3	3	.SH NAME
4	4	mdb_stat \- LMDB environment status tool
5	5	.SH SYNOPSIS
6	6	.B mdb_stat
7	7	.BR \ envpath
	8	[\c
	9	.BR \-V ]
8	10	[\c
9	11	.BR \-e ]
10	12	[\c

21	23	.B mdb_stat
22	24	utility displays the status of an LMDB environment.
23	25	.SH OPTIONS
	26	.TP
	27	.BR \-V
	28	Write the library version number to the standard output, and exit.
24	29	.TP
25	30	.BR \-e
26	31	Display information about the database environment.

+21

-12

libraries/liblmdb/mdb_stat.c less more

36	36
37	37	static void usage(char *prog)
38	38	{
39		fprintf(stderr, "usage: %s dbpath [-n] [-e] [-r[r]] [-f[f[f]]] [-a\|-s subdb]\n", prog);
	39	fprintf(stderr, "usage: %s dbpath [-V] [-n] [-e] [-r[r]] [-f[f[f]]] [-a\|-s subdb]\n", prog);
40	40	exit(EXIT_FAILURE);
41	41	}
42	42

63	63	* -f: print freelist info
64	64	* -r: print reader info
65	65	* -n: use NOSUBDIR flag on env_open
	66	* -V: print version and exit
66	67	* (default) print stat of only the main DB
67	68	*/
68		while ((i = getopt(argc, argv, "aefnrs:")) != EOF) {
	69	while ((i = getopt(argc, argv, "Vaefnrs:")) != EOF) {
69	70	switch(i) {
	71	case 'V':
	72	printf("%s\n", MDB_VERSION_STRING);
	73	exit(0);
	74	break;
70	75	case 'a':
71	76	if (subname)
72	77	usage(prog);

99	104
100	105	envname = argv[optind];
101	106	rc = mdb_env_create(&env);
	107	if (rc) {
	108	fprintf(stderr, "mdb_env_create failed, error %d %s\n", rc, mdb_strerror(rc));
	109	return EXIT_FAILURE;
	110	}
102	111
103	112	if (alldbs \|\| subname) {
104	113	mdb_env_set_maxdbs(env, 4);

106	115
107	116	rc = mdb_env_open(env, envname, envflags \| MDB_RDONLY, 0664);
108	117	if (rc) {
109		printf("mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
	118	fprintf(stderr, "mdb_env_open failed, error %d %s\n", rc, mdb_strerror(rc));
110	119	goto env_close;
111	120	}
112	121
113	122	if (envinfo) {
114		rc = mdb_env_stat(env, &mst);
115		rc = mdb_env_info(env, &mei);
	123	(void)mdb_env_stat(env, &mst);
	124	(void)mdb_env_info(env, &mei);
116	125	printf("Environment Info\n");
117	126	printf(" Map address: %p\n", mei.me_mapaddr);
118	127	printf(" Map size: %"Z"u\n", mei.me_mapsize);

139	148
140	149	rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
141	150	if (rc) {
142		printf("mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
	151	fprintf(stderr, "mdb_txn_begin failed, error %d %s\n", rc, mdb_strerror(rc));
143	152	goto env_close;
144	153	}
145	154

152	161	dbi = 0;
153	162	rc = mdb_cursor_open(txn, dbi, &cursor);
154	163	if (rc) {
155		printf("mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
	164	fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
156	165	goto txn_abort;
157	166	}
158	167	rc = mdb_stat(txn, dbi, &mst);
159	168	if (rc) {
160		printf("mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
	169	fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
161	170	goto txn_abort;
162	171	}
163	172	prstat(&mst);

195	204
196	205	rc = mdb_open(txn, subname, 0, &dbi);
197	206	if (rc) {
198		printf("mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
	207	fprintf(stderr, "mdb_open failed, error %d %s\n", rc, mdb_strerror(rc));
199	208	goto txn_abort;
200	209	}
201	210
202	211	rc = mdb_stat(txn, dbi, &mst);
203	212	if (rc) {
204		printf("mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
	213	fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
205	214	goto txn_abort;
206	215	}
207	216	printf("Status of %s\n", subname ? subname : "Main DB");

213	222
214	223	rc = mdb_cursor_open(txn, dbi, &cursor);
215	224	if (rc) {
216		printf("mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
	225	fprintf(stderr, "mdb_cursor_open failed, error %d %s\n", rc, mdb_strerror(rc));
217	226	goto txn_abort;
218	227	}
219	228	while ((rc = mdb_cursor_get(cursor, &key, NULL, MDB_NEXT_NODUP)) == 0) {

231	240	if (rc) continue;
232	241	rc = mdb_stat(txn, db2, &mst);
233	242	if (rc) {
234		printf("mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
	243	fprintf(stderr, "mdb_stat failed, error %d %s\n", rc, mdb_strerror(rc));
235	244	goto txn_abort;
236	245	}
237	246	prstat(&mst);

+16

-2

libraries/liblmdb/midl.c less more

2	2	/* $OpenLDAP$ */
3	3	/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4	4	*
5		* Copyright 2000-2013 The OpenLDAP Foundation.
	5	* Copyright 2000-2014 The OpenLDAP Foundation.
6	6	* All rights reserved.
7	7	*
8	8	* Redistribution and use in source and binary forms, with or without

21	21	#include <sys/types.h>
22	22	#include "midl.h"
23	23
24		/** @defgroup internal MDB Internals
	24	/** @defgroup internal LMDB Internals
25	25	* @{
26	26	*/
27	27	/** @defgroup idls ID List Management

196	196	while (n)
197	197	ids[n--] = id++;
198	198	return 0;
	199	}
	200
	201	void mdb_midl_xmerge( MDB_IDL idl, MDB_IDL merge )
	202	{
	203	MDB_ID old_id, merge_id, i = merge[0], j = idl[0], k = i+j, total = k;
	204	idl[0] = (MDB_ID)-1; /* delimiter for idl scan below */
	205	old_id = idl[j];
	206	while (i) {
	207	merge_id = merge[i--];
	208	for (; old_id < merge_id; old_id = idl[--j])
	209	idl[k--] = old_id;
	210	idl[k--] = merge_id;
	211	}
	212	idl[0] = total;
199	213	}
200	214
201	215	/* Quicksort + Insertion sort for small arrays */

+12

-3

libraries/liblmdb/midl.h less more

0	0	/** @file midl.h
1		* @brief mdb ID List header file.
	1	* @brief LMDB ID List header file.
2	2	*
3	3	* This file was originally part of back-bdb but has been
4	4	* modified for use in libmdb. Most of the macros defined

10	10	/* $OpenLDAP$ */
11	11	/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
12	12	*
13		* Copyright 2000-2013 The OpenLDAP Foundation.
	13	* Copyright 2000-2014 The OpenLDAP Foundation.
14	14	* All rights reserved.
15	15	*
16	16	* Redistribution and use in source and binary forms, with or without

31	31	extern "C" {
32	32	#endif
33	33
34		/** @defgroup internal MDB Internals
	34	/** @defgroup internal LMDB Internals
35	35	* @{
36	36	*/
37	37

66	66	#define MDB_IDL_CPY( dst, src ) (memcpy( dst, src, MDB_IDL_SIZEOF( src ) ))
67	67	#define MDB_IDL_FIRST( ids ) ( (ids)[1] )
68	68	#define MDB_IDL_LAST( ids ) ( (ids)[(ids)[0]] )
	69
	70	/** Current max length of an #mdb_midl_alloc()ed IDL */
	71	#define MDB_IDL_ALLOCLEN( ids ) ( (ids)[-1] )
69	72
70	73	/** Append ID to IDL. The IDL must be big enough. */
71	74	#define mdb_midl_xappend(idl, id) do { \

127	130	*/
128	131	int mdb_midl_append_range( MDB_IDL *idp, MDB_ID id, unsigned n );
129	132
	133	/** Merge an IDL onto an IDL. The destination IDL must be big enough.
	134	* @param[in] idl The IDL to merge into.
	135	* @param[in] merge The IDL to merge.
	136	*/
	137	void mdb_midl_xmerge( MDB_IDL idl, MDB_IDL merge );
	138
130	139	/** Sort an IDL.
131	140	* @param[in,out] ids The IDL to sort.
132	141	*/

+46

-49

libraries/liblmdb/mtest.c less more

0	0	/* mtest.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

10	10	* top-level directory of the distribution or, alternatively, at
11	11	* <http://www.OpenLDAP.org/license.html>.
12	12	*/
13		#define _XOPEN_SOURCE 500 /* srandom(), random() */
14	13	#include <stdio.h>
15	14	#include <stdlib.h>
16	15	#include <time.h>
17	16	#include "lmdb.h"
	17
	18	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	19	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	20	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	21	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
18	22
19	23	int main(int argc,char * argv[])
20	24	{

25	29	MDB_txn *txn;
26	30	MDB_stat mst;
27	31	MDB_cursor cursor, cur2;
	32	MDB_cursor_op op;
28	33	int count;
29	34	int *values;
30	35	char sval[32] = "";
31	36
32		srandom(time(NULL));
	37	srand(time(NULL));
33	38
34		count = (random()%384) + 64;
	39	count = (rand()%384) + 64;
35	40	values = (int )malloc(countsizeof(int));
36	41
37	42	for(i = 0;i<count;i++) {
38		values[i] = random()%1024;
	43	values[i] = rand()%1024;
39	44	}
40	45
41		rc = mdb_env_create(&env);
42		rc = mdb_env_set_mapsize(env, 10485760);
43		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP /\|MDB_NOSYNC/, 0664);
44		rc = mdb_txn_begin(env, NULL, 0, &txn);
45		rc = mdb_open(txn, NULL, 0, &dbi);
	46	E(mdb_env_create(&env));
	47	E(mdb_env_set_mapsize(env, 10485760));
	48	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP /\|MDB_NOSYNC/, 0664));
	49	E(mdb_txn_begin(env, NULL, 0, &txn));
	50	E(mdb_open(txn, NULL, 0, &dbi));
46	51
47	52	key.mv_size = sizeof(int);
48	53	key.mv_data = sval;

52	57	printf("Adding %d values\n", count);
53	58	for (i=0;i<count;i++) {
54	59	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
55		rc = mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE);
56		if (rc) {
	60	if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE))) {
57	61	j++;
58	62	data.mv_size = sizeof(sval);
59	63	data.mv_data = sval;
60	64	}
61	65	}
62	66	if (j) printf("%d duplicates skipped\n", j);
63		rc = mdb_txn_commit(txn);
64		rc = mdb_env_stat(env, &mst);
	67	E(mdb_txn_commit(txn));
	68	E(mdb_env_stat(env, &mst));
65	69
66		rc = mdb_txn_begin(env, NULL, 1, &txn);
67		rc = mdb_cursor_open(txn, dbi, &cursor);
	70	E(mdb_txn_begin(env, NULL, 1, &txn));
	71	E(mdb_cursor_open(txn, dbi, &cursor));
68	72	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
69	73	printf("key: %p %.s, data: %p %.s\n",
70	74	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
71	75	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
72	76	}
	77	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
73	78	mdb_cursor_close(cursor);
74	79	mdb_txn_abort(txn);
75	80
76	81	j=0;
77	82	key.mv_data = sval;
78		for (i= count - 1; i > -1; i-= (random()%5)) {
	83	for (i= count - 1; i > -1; i-= (rand()%5)) {
79	84	j++;
80	85	txn=NULL;
81		rc = mdb_txn_begin(env, NULL, 0, &txn);
	86	E(mdb_txn_begin(env, NULL, 0, &txn));
82	87	sprintf(sval, "%03x ", values[i]);
83		rc = mdb_del(txn, dbi, &key, NULL);
84		if (rc) {
	88	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, NULL))) {
85	89	j--;
86	90	mdb_txn_abort(txn);
87	91	} else {
88		rc = mdb_txn_commit(txn);
	92	E(mdb_txn_commit(txn));
89	93	}
90	94	}
91	95	free(values);
92	96	printf("Deleted %d values\n", j);
93	97
94		rc = mdb_env_stat(env, &mst);
95		rc = mdb_txn_begin(env, NULL, 1, &txn);
96		rc = mdb_cursor_open(txn, dbi, &cursor);
	98	E(mdb_env_stat(env, &mst));
	99	E(mdb_txn_begin(env, NULL, 1, &txn));
	100	E(mdb_cursor_open(txn, dbi, &cursor));
97	101	printf("Cursor next\n");
98	102	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
99	103	printf("key: %.s, data: %.s\n",
100	104	(int) key.mv_size, (char *) key.mv_data,
101	105	(int) data.mv_size, (char *) data.mv_data);
102	106	}
	107	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
103	108	printf("Cursor last\n");
104		rc = mdb_cursor_get(cursor, &key, &data, MDB_LAST);
	109	E(mdb_cursor_get(cursor, &key, &data, MDB_LAST));
105	110	printf("key: %.s, data: %.s\n",
106	111	(int) key.mv_size, (char *) key.mv_data,
107	112	(int) data.mv_size, (char *) data.mv_data);

111	116	(int) key.mv_size, (char *) key.mv_data,
112	117	(int) data.mv_size, (char *) data.mv_data);
113	118	}
	119	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
114	120	printf("Cursor last/prev\n");
115		rc = mdb_cursor_get(cursor, &key, &data, MDB_LAST);
	121	E(mdb_cursor_get(cursor, &key, &data, MDB_LAST));
116	122	printf("key: %.s, data: %.s\n",
117	123	(int) key.mv_size, (char *) key.mv_data,
118	124	(int) data.mv_size, (char *) data.mv_data);
119		rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV);
	125	E(mdb_cursor_get(cursor, &key, &data, MDB_PREV));
120	126	printf("key: %.s, data: %.s\n",
121	127	(int) key.mv_size, (char *) key.mv_data,
122	128	(int) data.mv_size, (char *) data.mv_data);

124	130	mdb_txn_abort(txn);
125	131
126	132	printf("Deleting with cursor\n");
127		rc = mdb_txn_begin(env, NULL, 0, &txn);
128		rc = mdb_cursor_open(txn, dbi, &cur2);
	133	E(mdb_txn_begin(env, NULL, 0, &txn));
	134	E(mdb_cursor_open(txn, dbi, &cur2));
129	135	for (i=0; i<50; i++) {
130		rc = mdb_cursor_get(cur2, &key, &data, MDB_NEXT);
131		if (rc)
	136	if (RES(MDB_NOTFOUND, mdb_cursor_get(cur2, &key, &data, MDB_NEXT)))
132	137	break;
133	138	printf("key: %p %.s, data: %p %.s\n",
134	139	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
135	140	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
136		rc = mdb_del(txn, dbi, &key, NULL);
	141	E(mdb_del(txn, dbi, &key, NULL));
137	142	}
138	143
139	144	printf("Restarting cursor in txn\n");
140		rc = mdb_cursor_get(cur2, &key, &data, MDB_FIRST);
141		printf("key: %p %.s, data: %p %.s\n",
142		key.mv_data, (int) key.mv_size, (char *) key.mv_data,
143		data.mv_data, (int) data.mv_size, (char *) data.mv_data);
144		for (i=0; i<32; i++) {
145		rc = mdb_cursor_get(cur2, &key, &data, MDB_NEXT);
146		if (rc) break;
	145	for (op=MDB_FIRST, i=0; i<=32; op=MDB_NEXT, i++) {
	146	if (RES(MDB_NOTFOUND, mdb_cursor_get(cur2, &key, &data, op)))
	147	break;
147	148	printf("key: %p %.s, data: %p %.s\n",
148	149	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
149	150	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
150	151	}
151	152	mdb_cursor_close(cur2);
152		rc = mdb_txn_commit(txn);
	153	E(mdb_txn_commit(txn));
153	154
154	155	printf("Restarting cursor outside txn\n");
155		rc = mdb_txn_begin(env, NULL, 0, &txn);
156		rc = mdb_cursor_open(txn, dbi, &cursor);
157		rc = mdb_cursor_get(cursor, &key, &data, MDB_FIRST);
158		printf("key: %p %.s, data: %p %.s\n",
159		key.mv_data, (int) key.mv_size, (char *) key.mv_data,
160		data.mv_data, (int) data.mv_size, (char *) data.mv_data);
161		for (i=0; i<32; i++) {
162		rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT);
163		if (rc) break;
	156	E(mdb_txn_begin(env, NULL, 0, &txn));
	157	E(mdb_cursor_open(txn, dbi, &cursor));
	158	for (op=MDB_FIRST, i=0; i<=32; op=MDB_NEXT, i++) {
	159	if (RES(MDB_NOTFOUND, mdb_cursor_get(cursor, &key, &data, op)))
	160	break;
164	161	printf("key: %p %.s, data: %p %.s\n",
165	162	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
166	163	data.mv_data, (int) data.mv_size, (char *) data.mv_data);

+31

-25

libraries/liblmdb/mtest2.c less more

0	0	/* mtest2.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

13	13
14	14	/* Just like mtest.c, but using a subDB instead of the main DB */
15	15
16		#define _XOPEN_SOURCE 500 /* srandom(), random() */
17	16	#include <stdio.h>
18	17	#include <stdlib.h>
19	18	#include <time.h>
20	19	#include "lmdb.h"
	20
	21	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	22	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	23	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	24	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
21	25
22	26	int main(int argc,char * argv[])
23	27	{

32	36	int *values;
33	37	char sval[32] = "";
34	38
35		srandom(time(NULL));
	39	srand(time(NULL));
36	40
37		count = (random()%384) + 64;
	41	count = (rand()%384) + 64;
38	42	values = (int )malloc(countsizeof(int));
39	43
40	44	for(i = 0;i<count;i++) {
41		values[i] = random()%1024;
	45	values[i] = rand()%1024;
42	46	}
43	47
44		rc = mdb_env_create(&env);
45		rc = mdb_env_set_mapsize(env, 10485760);
46		rc = mdb_env_set_maxdbs(env, 4);
47		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664);
48		rc = mdb_txn_begin(env, NULL, 0, &txn);
49		rc = mdb_open(txn, "id1", MDB_CREATE, &dbi);
	48	E(mdb_env_create(&env));
	49	E(mdb_env_set_mapsize(env, 10485760));
	50	E(mdb_env_set_maxdbs(env, 4));
	51	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664));
	52	E(mdb_txn_begin(env, NULL, 0, &txn));
	53	E(mdb_open(txn, "id1", MDB_CREATE, &dbi));
50	54
51	55	key.mv_size = sizeof(int);
52	56	key.mv_data = sval;

56	60	printf("Adding %d values\n", count);
57	61	for (i=0;i<count;i++) {
58	62	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
59		rc = mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE);
60		if (rc) j++;
	63	if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE)))
	64	j++;
61	65	}
62	66	if (j) printf("%d duplicates skipped\n", j);
63		rc = mdb_txn_commit(txn);
64		rc = mdb_env_stat(env, &mst);
	67	E(mdb_txn_commit(txn));
	68	E(mdb_env_stat(env, &mst));
65	69
66		rc = mdb_txn_begin(env, NULL, 1, &txn);
67		rc = mdb_cursor_open(txn, dbi, &cursor);
	70	E(mdb_txn_begin(env, NULL, 1, &txn));
	71	E(mdb_cursor_open(txn, dbi, &cursor));
68	72	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
69	73	printf("key: %p %.s, data: %p %.s\n",
70	74	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
71	75	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
72	76	}
	77	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
73	78	mdb_cursor_close(cursor);
74	79	mdb_txn_abort(txn);
75	80
76	81	j=0;
77	82	key.mv_data = sval;
78		for (i= count - 1; i > -1; i-= (random()%5)) {
	83	for (i= count - 1; i > -1; i-= (rand()%5)) {
79	84	j++;
80	85	txn=NULL;
81		rc = mdb_txn_begin(env, NULL, 0, &txn);
	86	E(mdb_txn_begin(env, NULL, 0, &txn));
82	87	sprintf(sval, "%03x ", values[i]);
83		rc = mdb_del(txn, dbi, &key, NULL);
84		if (rc) {
	88	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, NULL))) {
85	89	j--;
86	90	mdb_txn_abort(txn);
87	91	} else {
88		rc = mdb_txn_commit(txn);
	92	E(mdb_txn_commit(txn));
89	93	}
90	94	}
91	95	free(values);
92	96	printf("Deleted %d values\n", j);
93	97
94		rc = mdb_env_stat(env, &mst);
95		rc = mdb_txn_begin(env, NULL, 1, &txn);
96		rc = mdb_cursor_open(txn, dbi, &cursor);
	98	E(mdb_env_stat(env, &mst));
	99	E(mdb_txn_begin(env, NULL, 1, &txn));
	100	E(mdb_cursor_open(txn, dbi, &cursor));
97	101	printf("Cursor next\n");
98	102	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
99	103	printf("key: %.s, data: %.s\n",
100	104	(int) key.mv_size, (char *) key.mv_data,
101	105	(int) data.mv_size, (char *) data.mv_data);
102	106	}
	107	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
103	108	printf("Cursor prev\n");
104	109	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
105	110	printf("key: %.s, data: %.s\n",
106	111	(int) key.mv_size, (char *) key.mv_data,
107	112	(int) data.mv_size, (char *) data.mv_data);
108	113	}
	114	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
109	115	mdb_cursor_close(cursor);
110	116	mdb_close(env, dbi);
111	117

+31

-25

libraries/liblmdb/mtest3.c less more

0	0	/* mtest3.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

12	12	*/
13	13
14	14	/* Tests for sorted duplicate DBs */
15		#define _XOPEN_SOURCE 500 /* srandom(), random() */
16	15	#include <stdio.h>
17	16	#include <stdlib.h>
18	17	#include <string.h>
19	18	#include <time.h>
20	19	#include "lmdb.h"
	20
	21	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	22	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	23	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	24	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
21	25
22	26	int main(int argc,char * argv[])
23	27	{

33	37	char sval[32];
34	38	char kval[sizeof(int)];
35	39
36		srandom(time(NULL));
	40	srand(time(NULL));
37	41
38	42	memset(sval, 0, sizeof(sval));
39	43
40		count = (random()%384) + 64;
	44	count = (rand()%384) + 64;
41	45	values = (int )malloc(countsizeof(int));
42	46
43	47	for(i = 0;i<count;i++) {
44		values[i] = random()%1024;
	48	values[i] = rand()%1024;
45	49	}
46	50
47		rc = mdb_env_create(&env);
48		rc = mdb_env_set_mapsize(env, 10485760);
49		rc = mdb_env_set_maxdbs(env, 4);
50		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664);
51		rc = mdb_txn_begin(env, NULL, 0, &txn);
52		rc = mdb_open(txn, "id2", MDB_CREATE\|MDB_DUPSORT, &dbi);
	51	E(mdb_env_create(&env));
	52	E(mdb_env_set_mapsize(env, 10485760));
	53	E(mdb_env_set_maxdbs(env, 4));
	54	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664));
	55	E(mdb_txn_begin(env, NULL, 0, &txn));
	56	E(mdb_open(txn, "id2", MDB_CREATE\|MDB_DUPSORT, &dbi));
53	57
54	58	key.mv_size = sizeof(int);
55	59	key.mv_data = kval;

61	65	if (!(i & 0x0f))
62	66	sprintf(kval, "%03x", values[i]);
63	67	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
64		rc = mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA);
65		if (rc) j++;
	68	if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA)))
	69	j++;
66	70	}
67	71	if (j) printf("%d duplicates skipped\n", j);
68		rc = mdb_txn_commit(txn);
69		rc = mdb_env_stat(env, &mst);
	72	E(mdb_txn_commit(txn));
	73	E(mdb_env_stat(env, &mst));
70	74
71		rc = mdb_txn_begin(env, NULL, 1, &txn);
72		rc = mdb_cursor_open(txn, dbi, &cursor);
	75	E(mdb_txn_begin(env, NULL, 1, &txn));
	76	E(mdb_cursor_open(txn, dbi, &cursor));
73	77	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
74	78	printf("key: %p %.s, data: %p %.s\n",
75	79	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
76	80	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
77	81	}
	82	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
78	83	mdb_cursor_close(cursor);
79	84	mdb_txn_abort(txn);
80	85
81	86	j=0;
82	87
83		for (i= count - 1; i > -1; i-= (random()%5)) {
	88	for (i= count - 1; i > -1; i-= (rand()%5)) {
84	89	j++;
85	90	txn=NULL;
86		rc = mdb_txn_begin(env, NULL, 0, &txn);
	91	E(mdb_txn_begin(env, NULL, 0, &txn));
87	92	sprintf(kval, "%03x", values[i & ~0x0f]);
88	93	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
89	94	key.mv_size = sizeof(int);
90	95	key.mv_data = kval;
91	96	data.mv_size = sizeof(sval);
92	97	data.mv_data = sval;
93		rc = mdb_del(txn, dbi, &key, &data);
94		if (rc) {
	98	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, &data))) {
95	99	j--;
96	100	mdb_txn_abort(txn);
97	101	} else {
98		rc = mdb_txn_commit(txn);
	102	E(mdb_txn_commit(txn));
99	103	}
100	104	}
101	105	free(values);
102	106	printf("Deleted %d values\n", j);
103	107
104		rc = mdb_env_stat(env, &mst);
105		rc = mdb_txn_begin(env, NULL, 1, &txn);
106		rc = mdb_cursor_open(txn, dbi, &cursor);
	108	E(mdb_env_stat(env, &mst));
	109	E(mdb_txn_begin(env, NULL, 1, &txn));
	110	E(mdb_cursor_open(txn, dbi, &cursor));
107	111	printf("Cursor next\n");
108	112	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
109	113	printf("key: %.s, data: %.s\n",
110	114	(int) key.mv_size, (char *) key.mv_data,
111	115	(int) data.mv_size, (char *) data.mv_data);
112	116	}
	117	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
113	118	printf("Cursor prev\n");
114	119	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
115	120	printf("key: %.s, data: %.s\n",
116	121	(int) key.mv_size, (char *) key.mv_data,
117	122	(int) data.mv_size, (char *) data.mv_data);
118	123	}
	124	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
119	125	mdb_cursor_close(cursor);
120	126	mdb_close(env, dbi);
121	127

+38

-31

libraries/liblmdb/mtest4.c less more

0	0	/* mtest4.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

12	12	*/
13	13
14	14	/* Tests for sorted duplicate DBs with fixed-size keys */
15		#define _XOPEN_SOURCE 500 /* srandom(), random() */
16	15	#include <stdio.h>
17	16	#include <stdlib.h>
18	17	#include <string.h>
19	18	#include <time.h>
20	19	#include "lmdb.h"
	20
	21	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	22	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	23	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	24	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
21	25
22	26	int main(int argc,char * argv[])
23	27	{

42	46	values[i] = i*5;
43	47	}
44	48
45		rc = mdb_env_create(&env);
46		rc = mdb_env_set_mapsize(env, 10485760);
47		rc = mdb_env_set_maxdbs(env, 4);
48		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664);
49		rc = mdb_txn_begin(env, NULL, 0, &txn);
50		rc = mdb_open(txn, "id2", MDB_CREATE\|MDB_DUPSORT\|MDB_DUPFIXED, &dbi);
	49	E(mdb_env_create(&env));
	50	E(mdb_env_set_mapsize(env, 10485760));
	51	E(mdb_env_set_maxdbs(env, 4));
	52	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664));
	53	E(mdb_txn_begin(env, NULL, 0, &txn));
	54	E(mdb_open(txn, "id4", MDB_CREATE\|MDB_DUPSORT\|MDB_DUPFIXED, &dbi));
51	55
52	56	key.mv_size = sizeof(int);
53	57	key.mv_data = kval;

58	62	strcpy(kval, "001");
59	63	for (i=0;i<count;i++) {
60	64	sprintf(sval, "%07x", values[i]);
61		rc = mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA);
62		if (rc) j++;
	65	if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA)))
	66	j++;
63	67	}
64	68	if (j) printf("%d duplicates skipped\n", j);
65		rc = mdb_txn_commit(txn);
66		rc = mdb_env_stat(env, &mst);
	69	E(mdb_txn_commit(txn));
	70	E(mdb_env_stat(env, &mst));
67	71
68	72	/* there should be one full page of dups now.
69	73	*/
70		rc = mdb_txn_begin(env, NULL, 1, &txn);
71		rc = mdb_cursor_open(txn, dbi, &cursor);
	74	E(mdb_txn_begin(env, NULL, 1, &txn));
	75	E(mdb_cursor_open(txn, dbi, &cursor));
72	76	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
73	77	printf("key: %p %.s, data: %p %.s\n",
74	78	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
75	79	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
76	80	}
	81	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
77	82	mdb_cursor_close(cursor);
78	83	mdb_txn_abort(txn);
79	84

89	94	data.mv_data = sval;
90	95
91	96	sprintf(sval, "%07x", values[3]+1);
92		rc = mdb_txn_begin(env, NULL, 0, &txn);
93		rc = mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA);
	97	E(mdb_txn_begin(env, NULL, 0, &txn));
	98	(void)RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA));
94	99	mdb_txn_abort(txn);
95	100
96	101	sprintf(sval, "%07x", values[255]+1);
97		rc = mdb_txn_begin(env, NULL, 0, &txn);
98		rc = mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA);
	102	E(mdb_txn_begin(env, NULL, 0, &txn));
	103	(void)RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA));
99	104	mdb_txn_abort(txn);
100	105
101	106	sprintf(sval, "%07x", values[500]+1);
102		rc = mdb_txn_begin(env, NULL, 0, &txn);
103		rc = mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA);
104		rc = mdb_txn_commit(txn);
	107	E(mdb_txn_begin(env, NULL, 0, &txn));
	108	(void)RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NODUPDATA));
	109	E(mdb_txn_commit(txn));
105	110
106	111	/* Try MDB_NEXT_MULTIPLE */
107		rc = mdb_txn_begin(env, NULL, 0, &txn);
108		rc = mdb_cursor_open(txn, dbi, &cursor);
	112	E(mdb_txn_begin(env, NULL, 0, &txn));
	113	E(mdb_cursor_open(txn, dbi, &cursor));
109	114	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT_MULTIPLE)) == 0) {
110	115	printf("key: %.s, data: %.s\n",
111	116	(int) key.mv_size, (char *) key.mv_data,
112	117	(int) data.mv_size, (char *) data.mv_data);
113	118	}
	119	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
114	120	mdb_cursor_close(cursor);
115	121	mdb_txn_abort(txn);
116	122	j=0;
117	123
118		for (i= count - 1; i > -1; i-= (random()%3)) {
	124	for (i= count - 1; i > -1; i-= (rand()%3)) {
119	125	j++;
120	126	txn=NULL;
121		rc = mdb_txn_begin(env, NULL, 0, &txn);
	127	E(mdb_txn_begin(env, NULL, 0, &txn));
122	128	sprintf(sval, "%07x", values[i]);
123	129	key.mv_size = sizeof(int);
124	130	key.mv_data = kval;
125	131	data.mv_size = sizeof(sval);
126	132	data.mv_data = sval;
127		rc = mdb_del(txn, dbi, &key, &data);
128		if (rc) {
	133	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, &data))) {
129	134	j--;
130	135	mdb_txn_abort(txn);
131	136	} else {
132		rc = mdb_txn_commit(txn);
	137	E(mdb_txn_commit(txn));
133	138	}
134	139	}
135	140	free(values);
136	141	printf("Deleted %d values\n", j);
137	142
138		rc = mdb_env_stat(env, &mst);
139		rc = mdb_txn_begin(env, NULL, 1, &txn);
140		rc = mdb_cursor_open(txn, dbi, &cursor);
	143	E(mdb_env_stat(env, &mst));
	144	E(mdb_txn_begin(env, NULL, 1, &txn));
	145	E(mdb_cursor_open(txn, dbi, &cursor));
141	146	printf("Cursor next\n");
142	147	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
143	148	printf("key: %.s, data: %.s\n",
144	149	(int) key.mv_size, (char *) key.mv_data,
145	150	(int) data.mv_size, (char *) data.mv_data);
146	151	}
	152	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
147	153	printf("Cursor prev\n");
148	154	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
149	155	printf("key: %.s, data: %.s\n",
150	156	(int) key.mv_size, (char *) key.mv_data,
151	157	(int) data.mv_size, (char *) data.mv_data);
152	158	}
	159	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
153	160	mdb_cursor_close(cursor);
154	161	mdb_close(env, dbi);
155	162

+32

-26

libraries/liblmdb/mtest5.c less more

0	0	/* mtest5.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

12	12	*/
13	13
14	14	/* Tests for sorted duplicate DBs using cursor_put */
15		#define _XOPEN_SOURCE 500 /* srandom(), random() */
16	15	#include <stdio.h>
17	16	#include <stdlib.h>
18	17	#include <string.h>
19	18	#include <time.h>
20	19	#include "lmdb.h"
	20
	21	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	22	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	23	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	24	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
21	25
22	26	int main(int argc,char * argv[])
23	27	{

33	37	char sval[32];
34	38	char kval[sizeof(int)];
35	39
36		srandom(time(NULL));
	40	srand(time(NULL));
37	41
38	42	memset(sval, 0, sizeof(sval));
39	43
40		count = (random()%384) + 64;
	44	count = (rand()%384) + 64;
41	45	values = (int )malloc(countsizeof(int));
42	46
43	47	for(i = 0;i<count;i++) {
44		values[i] = random()%1024;
	48	values[i] = rand()%1024;
45	49	}
46	50
47		rc = mdb_env_create(&env);
48		rc = mdb_env_set_mapsize(env, 10485760);
49		rc = mdb_env_set_maxdbs(env, 4);
50		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664);
51		rc = mdb_txn_begin(env, NULL, 0, &txn);
52		rc = mdb_open(txn, "id2", MDB_CREATE\|MDB_DUPSORT, &dbi);
53		rc = mdb_cursor_open(txn, dbi, &cursor);
	51	E(mdb_env_create(&env));
	52	E(mdb_env_set_mapsize(env, 10485760));
	53	E(mdb_env_set_maxdbs(env, 4));
	54	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664));
	55	E(mdb_txn_begin(env, NULL, 0, &txn));
	56	E(mdb_open(txn, "id2", MDB_CREATE\|MDB_DUPSORT, &dbi));
	57	E(mdb_cursor_open(txn, dbi, &cursor));
54	58
55	59	key.mv_size = sizeof(int);
56	60	key.mv_data = kval;

62	66	if (!(i & 0x0f))
63	67	sprintf(kval, "%03x", values[i]);
64	68	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
65		rc = mdb_cursor_put(cursor, &key, &data, MDB_NODUPDATA);
66		if (rc) j++;
	69	if (RES(MDB_KEYEXIST, mdb_cursor_put(cursor, &key, &data, MDB_NODUPDATA)))
	70	j++;
67	71	}
68	72	if (j) printf("%d duplicates skipped\n", j);
69	73	mdb_cursor_close(cursor);
70		rc = mdb_txn_commit(txn);
71		rc = mdb_env_stat(env, &mst);
	74	E(mdb_txn_commit(txn));
	75	E(mdb_env_stat(env, &mst));
72	76
73		rc = mdb_txn_begin(env, NULL, 1, &txn);
74		rc = mdb_cursor_open(txn, dbi, &cursor);
	77	E(mdb_txn_begin(env, NULL, 1, &txn));
	78	E(mdb_cursor_open(txn, dbi, &cursor));
75	79	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
76	80	printf("key: %p %.s, data: %p %.s\n",
77	81	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
78	82	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
79	83	}
	84	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
80	85	mdb_cursor_close(cursor);
81	86	mdb_txn_abort(txn);
82	87
83	88	j=0;
84	89
85		for (i= count - 1; i > -1; i-= (random()%5)) {
	90	for (i= count - 1; i > -1; i-= (rand()%5)) {
86	91	j++;
87	92	txn=NULL;
88		rc = mdb_txn_begin(env, NULL, 0, &txn);
	93	E(mdb_txn_begin(env, NULL, 0, &txn));
89	94	sprintf(kval, "%03x", values[i & ~0x0f]);
90	95	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
91	96	key.mv_size = sizeof(int);
92	97	key.mv_data = kval;
93	98	data.mv_size = sizeof(sval);
94	99	data.mv_data = sval;
95		rc = mdb_del(txn, dbi, &key, &data);
96		if (rc) {
	100	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, &data))) {
97	101	j--;
98	102	mdb_txn_abort(txn);
99	103	} else {
100		rc = mdb_txn_commit(txn);
	104	E(mdb_txn_commit(txn));
101	105	}
102	106	}
103	107	free(values);
104	108	printf("Deleted %d values\n", j);
105	109
106		rc = mdb_env_stat(env, &mst);
107		rc = mdb_txn_begin(env, NULL, 1, &txn);
108		rc = mdb_cursor_open(txn, dbi, &cursor);
	110	E(mdb_env_stat(env, &mst));
	111	E(mdb_txn_begin(env, NULL, 1, &txn));
	112	E(mdb_cursor_open(txn, dbi, &cursor));
109	113	printf("Cursor next\n");
110	114	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
111	115	printf("key: %.s, data: %.s\n",
112	116	(int) key.mv_size, (char *) key.mv_data,
113	117	(int) data.mv_size, (char *) data.mv_data);
114	118	}
	119	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
115	120	printf("Cursor prev\n");
116	121	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
117	122	printf("key: %.s, data: %.s\n",
118	123	(int) key.mv_size, (char *) key.mv_data,
119	124	(int) data.mv_size, (char *) data.mv_data);
120	125	}
	126	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
121	127	mdb_cursor_close(cursor);
122	128	mdb_close(env, dbi);
123	129

+30

-24

libraries/liblmdb/mtest6.c less more

0	0	/* mtest6.c - memory-mapped database tester/toy */
1	1	/*
2		* Copyright 2011 Howard Chu, Symas Corp.
	2	* Copyright 2011-2014 Howard Chu, Symas Corp.
3	3	* All rights reserved.
4	4	*
5	5	* Redistribution and use in source and binary forms, with or without

12	12	*/
13	13
14	14	/* Tests for DB splits and merges */
15		#define _XOPEN_SOURCE 500 /* srandom(), random() */
16	15	#include <stdio.h>
17	16	#include <stdlib.h>
18	17	#include <string.h>
19	18	#include <time.h>
20	19	#include "lmdb.h"
	20
	21	#define E(expr) CHECK((rc = (expr)) == MDB_SUCCESS, #expr)
	22	#define RES(err, expr) ((rc = expr) == (err) \|\| (CHECK(!rc, #expr), 0))
	23	#define CHECK(test, msg) ((test) ? (void)0 : ((void)fprintf(stderr, \
	24	"%s:%d: %s: %s\n", __FILE__, __LINE__, msg, mdb_strerror(rc)), abort()))
21	25
22	26	char dkbuf[1024];
23	27

35	39	long kval;
36	40	char *sval;
37	41
38		srandom(time(NULL));
	42	srand(time(NULL));
39	43
40		rc = mdb_env_create(&env);
41		rc = mdb_env_set_mapsize(env, 10485760);
42		rc = mdb_env_set_maxdbs(env, 4);
43		rc = mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664);
44		rc = mdb_txn_begin(env, NULL, 0, &txn);
45		rc = mdb_open(txn, "id2", MDB_CREATE\|MDB_INTEGERKEY, &dbi);
46		rc = mdb_cursor_open(txn, dbi, &cursor);
47		rc = mdb_stat(txn, dbi, &mst);
	44	E(mdb_env_create(&env));
	45	E(mdb_env_set_mapsize(env, 10485760));
	46	E(mdb_env_set_maxdbs(env, 4));
	47	E(mdb_env_open(env, "./testdb", MDB_FIXEDMAP\|MDB_NOSYNC, 0664));
	48	E(mdb_txn_begin(env, NULL, 0, &txn));
	49	E(mdb_open(txn, "id6", MDB_CREATE\|MDB_INTEGERKEY, &dbi));
	50	E(mdb_cursor_open(txn, dbi, &cursor));
	51	E(mdb_stat(txn, dbi, &mst));
48	52
49	53	sval = calloc(1, mst.ms_psize / 4);
50	54	key.mv_size = sizeof(long);

56	60	for (i=0;i<12;i++) {
57	61	kval = i*5;
58	62	sprintf(sval, "%08x", kval);
59		rc = mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE);
	63	(void)RES(MDB_KEYEXIST, mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE));
60	64	}
61	65	printf("Adding 12 more values, should yield 3 splits\n");
62	66	for (i=0;i<12;i++) {
63	67	kval = i*5+4;
64	68	sprintf(sval, "%08x", kval);
65		rc = mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE);
	69	(void)RES(MDB_KEYEXIST, mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE));
66	70	}
67	71	printf("Adding 12 more values, should yield 3 splits\n");
68	72	for (i=0;i<12;i++) {
69	73	kval = i*5+1;
70	74	sprintf(sval, "%08x", kval);
71		rc = mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE);
	75	(void)RES(MDB_KEYEXIST, mdb_cursor_put(cursor, &key, &data, MDB_NOOVERWRITE));
72	76	}
73		rc = mdb_cursor_get(cursor, &key, &data, MDB_FIRST);
	77	E(mdb_cursor_get(cursor, &key, &data, MDB_FIRST));
74	78
75	79	do {
76	80	printf("key: %p %s, data: %p %.*s\n",
77	81	key.mv_data, mdb_dkey(&key, dkbuf),
78	82	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
79	83	} while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0);
	84	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
80	85	mdb_cursor_close(cursor);
81	86	mdb_txn_commit(txn);
82	87
83	88	#if 0
84	89	j=0;
85	90
86		for (i= count - 1; i > -1; i-= (random()%5)) {
	91	for (i= count - 1; i > -1; i-= (rand()%5)) {
87	92	j++;
88	93	txn=NULL;
89		rc = mdb_txn_begin(env, NULL, 0, &txn);
	94	E(mdb_txn_begin(env, NULL, 0, &txn));
90	95	sprintf(kval, "%03x", values[i & ~0x0f]);
91	96	sprintf(sval, "%03x %d foo bar", values[i], values[i]);
92	97	key.mv_size = sizeof(int);
93	98	key.mv_data = kval;
94	99	data.mv_size = sizeof(sval);
95	100	data.mv_data = sval;
96		rc = mdb_del(txn, dbi, &key, &data);
97		if (rc) {
	101	if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, &data))) {
98	102	j--;
99	103	mdb_txn_abort(txn);
100	104	} else {
101		rc = mdb_txn_commit(txn);
	105	E(mdb_txn_commit(txn));
102	106	}
103	107	}
104	108	free(values);
105	109	printf("Deleted %d values\n", j);
106	110
107		rc = mdb_env_stat(env, &mst);
108		rc = mdb_txn_begin(env, NULL, 1, &txn);
109		rc = mdb_cursor_open(txn, dbi, &cursor);
	111	E(mdb_env_stat(env, &mst));
	112	E(mdb_txn_begin(env, NULL, 1, &txn));
	113	E(mdb_cursor_open(txn, dbi, &cursor));
110	114	printf("Cursor next\n");
111	115	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
112	116	printf("key: %.s, data: %.s\n",
113	117	(int) key.mv_size, (char *) key.mv_data,
114	118	(int) data.mv_size, (char *) data.mv_data);
115	119	}
	120	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
116	121	printf("Cursor prev\n");
117	122	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) {
118	123	printf("key: %.s, data: %.s\n",
119	124	(int) key.mv_size, (char *) key.mv_data,
120	125	(int) data.mv_size, (char *) data.mv_data);
121	126	}
	127	CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get");
122	128	mdb_cursor_close(cursor);
123		mdb_close(txn, dbi);
	129	mdb_close(env, dbi);
124	130
125	131	mdb_txn_abort(txn);
126	132	#endif

-71

~~libraries/liblmdb/sample-bdb.c~~ less more

0		/* sample-bdb.c - BerkeleyDB toy/sample
1		*
2		* Do a line-by-line comparison of this and sample-mdb.c
3		*/
4		/*
5		* Copyright 2012 Howard Chu, Symas Corp.
6		* All rights reserved.
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted only as authorized by the OpenLDAP
10		* Public License.
11		*
12		* A copy of this license is available in the file LICENSE in the
13		* top-level directory of the distribution or, alternatively, at
14		* <http://www.OpenLDAP.org/license.html>.
15		*/
16		#include <stdio.h>
17		#include <string.h>
18		#include <db.h>
19
20		int main(int argc,char * argv[])
21		{
22		int rc;
23		DB_ENV *env;
24		DB *dbi;
25		DBT key, data;
26		DB_TXN *txn;
27		DBC *cursor;
28		char sval[32], kval[32];
29
30		#define FLAGS (DB_INIT_LOCK\|DB_INIT_LOG\|DB_INIT_TXN\|DB_INIT_MPOOL\|DB_CREATE\|DB_THREAD)
31		rc = db_env_create(&env, 0);
32		rc = env->open(env, "./testdb", FLAGS, 0664);
33		rc = db_create(&dbi, env, 0);
34		rc = env->txn_begin(env, NULL, &txn, 0);
35		rc = dbi->open(dbi, txn, "test.bdb", NULL, DB_BTREE, DB_CREATE, 0664);
36
37		memset(&key, 0, sizeof(DBT));
38		memset(&data, 0, sizeof(DBT));
39		key.size = sizeof(int);
40		key.data = sval;
41		data.size = sizeof(sval);
42		data.data = sval;
43
44		sprintf(sval, "%03x %d foo bar", 32, 3141592);
45		rc = dbi->put(dbi, txn, &key, &data, 0);
46		rc = txn->commit(txn, 0);
47		if (rc) {
48		fprintf(stderr, "txn->commit: (%d) %s\n", rc, db_strerror(rc));
49		goto leave;
50		}
51		rc = env->txn_begin(env, NULL, &txn, 0);
52		rc = dbi->cursor(dbi, txn, &cursor, 0);
53		key.flags = DB_DBT_USERMEM;
54		key.data = kval;
55		key.ulen = sizeof(kval);
56		data.flags = DB_DBT_USERMEM;
57		data.data = sval;
58		data.ulen = sizeof(sval);
59		while ((rc = cursor->c_get(cursor, &key, &data, DB_NEXT)) == 0) {
60		printf("key: %p %.s, data: %p %.s\n",
61		key.data, (int) key.size, (char *) key.data,
62		data.data, (int) data.size, (char *) data.data);
63		}
64		rc = cursor->c_close(cursor);
65		rc = txn->abort(txn);
66		leave:
67		rc = dbi->close(dbi, 0);
68		rc = env->close(env, 0);
69		return rc;
70		}

+73

-0

libraries/liblmdb/sample-bdb.txt less more

	0	/* sample-bdb.txt - BerkeleyDB toy/sample
	1	*
	2	* Do a line-by-line comparison of this and sample-mdb.txt
	3	*/
	4	/*
	5	* Copyright 2012 Howard Chu, Symas Corp.
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted only as authorized by the OpenLDAP
	10	* Public License.
	11	*
	12	* A copy of this license is available in the file LICENSE in the
	13	* top-level directory of the distribution or, alternatively, at
	14	* <http://www.OpenLDAP.org/license.html>.
	15	*/
	16	#include <stdio.h>
	17	#include <string.h>
	18	#include <db.h>
	19
	20	int main(int argc,char * argv[])
	21	{
	22	int rc;
	23	DB_ENV *env;
	24	DB *dbi;
	25	DBT key, data;
	26	DB_TXN *txn;
	27	DBC *cursor;
	28	char sval[32], kval[32];
	29
	30	/* Note: Most error checking omitted for simplicity */
	31
	32	#define FLAGS (DB_INIT_LOCK\|DB_INIT_LOG\|DB_INIT_TXN\|DB_INIT_MPOOL\|DB_CREATE\|DB_THREAD)
	33	rc = db_env_create(&env, 0);
	34	rc = env->open(env, "./testdb", FLAGS, 0664);
	35	rc = db_create(&dbi, env, 0);
	36	rc = env->txn_begin(env, NULL, &txn, 0);
	37	rc = dbi->open(dbi, txn, "test.bdb", NULL, DB_BTREE, DB_CREATE, 0664);
	38
	39	memset(&key, 0, sizeof(DBT));
	40	memset(&data, 0, sizeof(DBT));
	41	key.size = sizeof(int);
	42	key.data = sval;
	43	data.size = sizeof(sval);
	44	data.data = sval;
	45
	46	sprintf(sval, "%03x %d foo bar", 32, 3141592);
	47	rc = dbi->put(dbi, txn, &key, &data, 0);
	48	rc = txn->commit(txn, 0);
	49	if (rc) {
	50	fprintf(stderr, "txn->commit: (%d) %s\n", rc, db_strerror(rc));
	51	goto leave;
	52	}
	53	rc = env->txn_begin(env, NULL, &txn, 0);
	54	rc = dbi->cursor(dbi, txn, &cursor, 0);
	55	key.flags = DB_DBT_USERMEM;
	56	key.data = kval;
	57	key.ulen = sizeof(kval);
	58	data.flags = DB_DBT_USERMEM;
	59	data.data = sval;
	60	data.ulen = sizeof(sval);
	61	while ((rc = cursor->c_get(cursor, &key, &data, DB_NEXT)) == 0) {
	62	printf("key: %p %.s, data: %p %.s\n",
	63	key.data, (int) key.size, (char *) key.data,
	64	data.data, (int) data.size, (char *) data.data);
	65	}
	66	rc = cursor->c_close(cursor);
	67	rc = txn->abort(txn);
	68	leave:
	69	rc = dbi->close(dbi, 0);
	70	rc = env->close(env, 0);
	71	return rc;
	72	}

-60

~~libraries/liblmdb/sample-mdb.c~~ less more

0		/* sample-mdb.c - MDB toy/sample
1		*
2		* Do a line-by-line comparison of this and sample-bdb.c
3		*/
4		/*
5		* Copyright 2012 Howard Chu, Symas Corp.
6		* All rights reserved.
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted only as authorized by the OpenLDAP
10		* Public License.
11		*
12		* A copy of this license is available in the file LICENSE in the
13		* top-level directory of the distribution or, alternatively, at
14		* <http://www.OpenLDAP.org/license.html>.
15		*/
16		#include <stdio.h>
17		#include "lmdb.h"
18
19		int main(int argc,char * argv[])
20		{
21		int rc;
22		MDB_env *env;
23		MDB_dbi dbi;
24		MDB_val key, data;
25		MDB_txn *txn;
26		MDB_cursor *cursor;
27		char sval[32];
28
29		rc = mdb_env_create(&env);
30		rc = mdb_env_open(env, "./testdb", 0, 0664);
31		rc = mdb_txn_begin(env, NULL, 0, &txn);
32		rc = mdb_open(txn, NULL, 0, &dbi);
33
34		key.mv_size = sizeof(int);
35		key.mv_data = sval;
36		data.mv_size = sizeof(sval);
37		data.mv_data = sval;
38
39		sprintf(sval, "%03x %d foo bar", 32, 3141592);
40		rc = mdb_put(txn, dbi, &key, &data, 0);
41		rc = mdb_txn_commit(txn);
42		if (rc) {
43		fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
44		goto leave;
45		}
46		rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
47		rc = mdb_cursor_open(txn, dbi, &cursor);
48		while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
49		printf("key: %p %.s, data: %p %.s\n",
50		key.mv_data, (int) key.mv_size, (char *) key.mv_data,
51		data.mv_data, (int) data.mv_size, (char *) data.mv_data);
52		}
53		mdb_cursor_close(cursor);
54		mdb_txn_abort(txn);
55		leave:
56		mdb_close(env, dbi);
57		mdb_env_close(env);
58		return 0;
59		}

+62

-0

libraries/liblmdb/sample-mdb.txt less more

	0	/* sample-mdb.txt - MDB toy/sample
	1	*
	2	* Do a line-by-line comparison of this and sample-bdb.txt
	3	*/
	4	/*
	5	* Copyright 2012 Howard Chu, Symas Corp.
	6	* All rights reserved.
	7	*
	8	* Redistribution and use in source and binary forms, with or without
	9	* modification, are permitted only as authorized by the OpenLDAP
	10	* Public License.
	11	*
	12	* A copy of this license is available in the file LICENSE in the
	13	* top-level directory of the distribution or, alternatively, at
	14	* <http://www.OpenLDAP.org/license.html>.
	15	*/
	16	#include <stdio.h>
	17	#include "lmdb.h"
	18
	19	int main(int argc,char * argv[])
	20	{
	21	int rc;
	22	MDB_env *env;
	23	MDB_dbi dbi;
	24	MDB_val key, data;
	25	MDB_txn *txn;
	26	MDB_cursor *cursor;
	27	char sval[32];
	28
	29	/* Note: Most error checking omitted for simplicity */
	30
	31	rc = mdb_env_create(&env);
	32	rc = mdb_env_open(env, "./testdb", 0, 0664);
	33	rc = mdb_txn_begin(env, NULL, 0, &txn);
	34	rc = mdb_open(txn, NULL, 0, &dbi);
	35
	36	key.mv_size = sizeof(int);
	37	key.mv_data = sval;
	38	data.mv_size = sizeof(sval);
	39	data.mv_data = sval;
	40
	41	sprintf(sval, "%03x %d foo bar", 32, 3141592);
	42	rc = mdb_put(txn, dbi, &key, &data, 0);
	43	rc = mdb_txn_commit(txn);
	44	if (rc) {
	45	fprintf(stderr, "mdb_txn_commit: (%d) %s\n", rc, mdb_strerror(rc));
	46	goto leave;
	47	}
	48	rc = mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
	49	rc = mdb_cursor_open(txn, dbi, &cursor);
	50	while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) {
	51	printf("key: %p %.s, data: %p %.s\n",
	52	key.mv_data, (int) key.mv_size, (char *) key.mv_data,
	53	data.mv_data, (int) data.mv_size, (char *) data.mv_data);
	54	}
	55	mdb_cursor_close(cursor);
	56	mdb_txn_abort(txn);
	57	leave:
	58	mdb_close(env, dbi);
	59	mdb_env_close(env);
	60	return 0;
	61	}

+22

-0

libraries/liblmdb/tooltag less more

	0	<tagfile>
	1	<compound kind="page">
	2	<name>mdb_copy_1</name>
	3	<title>mdb_copy - environment copy tool</title>
	4	<filename>mdb_copy.1</filename>
	5	</compound>
	6	<compound kind="page">
	7	<name>mdb_dump_1</name>
	8	<title>mdb_dump - environment export tool</title>
	9	<filename>mdb_dump.1</filename>
	10	</compound>
	11	<compound kind="page">
	12	<name>mdb_load_1</name>
	13	<title>mdb_load - environment import tool</title>
	14	<filename>mdb_load.1</filename>
	15	</compound>
	16	<compound kind="page">
	17	<name>mdb_stat_1</name>
	18	<title>mdb_stat - environment status tool</title>
	19	<filename>mdb_stat.1</filename>
	20	</compound>
	21	</tagfile>