#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
+#ifdef MDB_VL32
+#define _FILE_OFFSET_BITS 64
+#endif
#ifdef _WIN32
#include <malloc.h>
#include <windows.h>
#define ESECT
#endif
-#ifdef _MSC_VER
+#ifdef _WIN32
#define CALL_CONV WINAPI
#else
#define CALL_CONV
#define GET_PAGESIZE(x) ((x) = sysconf(_SC_PAGE_SIZE))
#endif
+#ifdef MDB_VL32
+#ifdef _WIN32
+#define Y "I64"
+#else
+#define Y "ll"
+#endif
+#else
+#define Y Z
+#endif
+
#if defined(_WIN32) || defined(MDB_USE_POSIX_SEM)
#define MNAME_LEN 32
#elif defined(MDB_USE_SYSV_SEM)
pgno_t md_branch_pages; /**< number of internal pages */
pgno_t md_leaf_pages; /**< number of leaf pages */
pgno_t md_overflow_pages; /**< number of overflow pages */
- size_t md_entries; /**< number of data items */
+ pgno_t md_entries; /**< number of data items */
pgno_t md_root; /**< the root page of this tree */
} MDB_db;
uint32_t mm_magic;
/** Version number of this file. Must be set to #MDB_DATA_VERSION. */
uint32_t mm_version;
+#ifdef MDB_VL32
+ union { /* always zero since we don't support fixed mapping in MDB_VL32 */
+ MDB_ID mmun_ull;
+ void *mmun_address;
+ } mm_un;
+#define mm_address mm_un.mmun_address
+#else
void *mm_address; /**< address for fixed mapping */
- size_t mm_mapsize; /**< size of mmap region */
+#endif
+ pgno_t mm_mapsize; /**< size of mmap region */
MDB_db mm_dbs[CORE_DBS]; /**< first is free space, 2nd is main db */
/** The size of pages used in this DB */
#define mm_psize mm_dbs[FREE_DBI].md_pad
void *me_pbuf; /**< scratch area for DUPSORT put() */
MDB_txn *me_txn; /**< current write transaction */
MDB_txn *me_txn0; /**< prealloc'd write transaction */
- size_t me_mapsize; /**< size of the data memory map */
+ mdb_size_t me_mapsize; /**< size of the data memory map */
off_t me_size; /**< current file size */
pgno_t me_maxpg; /**< me_mapsize / me_psize */
MDB_dbx *me_dbxs; /**< array of static DB info */
case P_LEAF|P_LEAF2: type = "LEAF2 page"; break;
case P_LEAF|P_LEAF2|P_SUBP: type = "LEAF2 sub-page"; break;
case P_OVERFLOW:
- fprintf(stderr, "Overflow page %"Z"u pages %u%s\n",
+ fprintf(stderr, "Overflow page %"Y"u pages %u%s\n",
pgno, mp->mp_pages, state);
return;
case P_META:
- fprintf(stderr, "Meta-page %"Z"u txnid %"Z"u\n",
+ fprintf(stderr, "Meta-page %"Y"u txnid %"Y"u\n",
pgno, ((MDB_meta *)METADATA(mp))->mm_txnid);
return;
default:
- fprintf(stderr, "Bad page %"Z"u flags 0x%u\n", pgno, mp->mp_flags);
+ fprintf(stderr, "Bad page %"Y"u flags 0x%u\n", pgno, mp->mp_flags);
return;
}
nkeys = NUMKEYS(mp);
- fprintf(stderr, "%s %"Z"u numkeys %d%s\n", type, pgno, nkeys, state);
+ fprintf(stderr, "%s %"Y"u numkeys %d%s\n", type, pgno, nkeys, state);
for (i=0; i<nkeys; i++) {
if (IS_LEAF2(mp)) { /* LEAF2 pages have no mp_ptrs[] or node headers */
key.mv_data = node->mn_data;
nsize = NODESIZE + key.mv_size;
if (IS_BRANCH(mp)) {
- fprintf(stderr, "key %d: page %"Z"u, %s\n", i, NODEPGNO(node),
+ fprintf(stderr, "key %d: page %"Y"u, %s\n", i, NODEPGNO(node),
DKEY(&key));
total += nsize;
} else {
}
}
if (freecount + count + NUM_METAS != txn->mt_next_pgno) {
- fprintf(stderr, "audit: %lu freecount: %lu count: %lu total: %lu next_pgno: %lu\n",
+ fprintf(stderr, "audit: %"Y"u freecount: %"Y"u count: %"Y"u total: %"Y"u next_pgno: %"Y"u\n",
txn->mt_txnid, freecount, count+NUM_METAS,
freecount+count+NUM_METAS, txn->mt_next_pgno);
}
mdb_dcmp(MDB_txn *txn, MDB_dbi dbi, const MDB_val *a, const MDB_val *b)
{
MDB_cmp_func *dcmp = txn->mt_dbxs[dbi].md_dcmp;
-#if UINT_MAX < SIZE_MAX
- if (dcmp == mdb_cmp_int && a->mv_size == sizeof(size_t))
+#if UINT_MAX < SIZE_MAX || defined(MDB_VL32)
+ if (dcmp == mdb_cmp_int && a->mv_size == sizeof(mdb_size_t))
dcmp = mdb_cmp_clong;
#endif
return dcmp(a, b);
}
}
if (loose) {
- DPRINTF(("loosen db %d page %"Z"u", DDBI(mc),
+ DPRINTF(("loosen db %d page %"Y"u", DDBI(mc),
mp->mp_pgno));
NEXT_LOOSE_PAGE(mp) = txn->mt_loose_pgs;
txn->mt_loose_pgs = mp;
np = txn->mt_loose_pgs;
txn->mt_loose_pgs = NEXT_LOOSE_PAGE(np);
txn->mt_loose_count--;
- DPRINTF(("db %d use loose page %"Z"u", DDBI(mc),
+ DPRINTF(("db %d use loose page %"Y"u", DDBI(mc),
np->mp_pgno));
*mp = np;
return MDB_SUCCESS;
}
env->me_pglast = last;
#if (MDB_DEBUG) > 1
- DPRINTF(("IDL read txn %"Z"u root %"Z"u num %u",
+ DPRINTF(("IDL read txn %"Y"u root %"Y"u num %u",
last, txn->mt_dbs[FREE_DBI].md_root, i));
for (j = i; j; j--)
- DPRINTF(("IDL %"Z"u", idl[j]));
+ DPRINTF(("IDL %"Y"u", idl[j]));
#endif
/* Merge in descending sorted order */
mdb_midl_xmerge(mop, idl);
(rc = mdb_page_alloc(mc, 1, &np)))
goto fail;
pgno = np->mp_pgno;
- DPRINTF(("touched db %d page %"Z"u -> %"Z"u", DDBI(mc),
+ DPRINTF(("touched db %d page %"Y"u -> %"Y"u", DDBI(mc),
mp->mp_pgno, pgno));
mdb_cassert(mc, mp->mp_pgno != pgno);
mdb_midl_xappend(txn->mt_free_pgs, mp->mp_pgno);
rc = mdb_txn_renew0(txn);
if (rc == MDB_SUCCESS) {
- DPRINTF(("renew txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
+ DPRINTF(("renew txn %"Y"u%c %p on mdbenv %p, root page %"Y"u",
txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',
(void *)txn, (void *)txn->mt_env, txn->mt_dbs[MAIN_DBI].md_root));
}
} else {
txn->mt_flags |= flags; /* could not change txn=me_txn0 earlier */
*ret = txn;
- DPRINTF(("begin txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
+ DPRINTF(("begin txn %"Y"u%c %p on mdbenv %p, root page %"Y"u",
txn->mt_txnid, (flags & MDB_RDONLY) ? 'r' : 'w',
(void *) txn, (void *) env, txn->mt_dbs[MAIN_DBI].md_root));
}
return txn->mt_env;
}
-size_t
+mdb_size_t
mdb_txn_id(MDB_txn *txn)
{
if(!txn) return 0;
/* Export or close DBI handles opened in this txn */
mdb_dbis_update(txn, mode & MDB_END_UPDATE);
- DPRINTF(("%s txn %"Z"u%c %p on mdbenv %p, root page %"Z"u",
+ DPRINTF(("%s txn %"Y"u%c %p on mdbenv %p, root page %"Y"u",
names[mode & MDB_END_OPMASK],
txn->mt_txnid, (txn->mt_flags & MDB_TXN_RDONLY) ? 'r' : 'w',
(void *) txn, (void *)env, txn->mt_dbs[MAIN_DBI].md_root));
#if (MDB_DEBUG) > 1
{
unsigned int i = free_pgs[0];
- DPRINTF(("IDL write txn %"Z"u root %"Z"u num %u",
+ DPRINTF(("IDL write txn %"Y"u root %"Y"u num %u",
txn->mt_txnid, txn->mt_dbs[FREE_DBI].md_root, i));
for (; i; i--)
- DPRINTF(("IDL %"Z"u", free_pgs[i]));
+ DPRINTF(("IDL %"Y"u", free_pgs[i]));
}
#endif
continue;
MDB_ID2L dl = txn->mt_u.dirty_list;
unsigned psize = env->me_psize, j;
int i, pagecount = dl[0].mid, rc;
- size_t size = 0, pos = 0;
+ size_t size = 0;
+ off_t pos = 0;
pgno_t pgno = 0;
MDB_page *dp = NULL;
#ifdef _WIN32
OVERLAPPED ov;
#else
struct iovec iov[MDB_COMMIT_PAGES];
- ssize_t wpos = 0, wsize = 0, wres;
- size_t next_pos = 1; /* impossible pos, so pos != next_pos */
+ ssize_t wsize = 0, wres;
+ off_t wpos = 0, next_pos = 1; /* impossible pos, so pos != next_pos */
int n = 0;
#endif
wpos = pos;
wsize = 0;
}
- DPRINTF(("committing page %"Z"u", pgno));
+ DPRINTF(("committing page %"Y"u", pgno));
next_pos = pos + size;
iov[n].iov_len = size;
iov[n].iov_base = (char *)dp;
!(txn->mt_flags & (MDB_TXN_DIRTY|MDB_TXN_SPILLS)))
goto done;
- DPRINTF(("committing txn %"Z"u %p on mdbenv %p, root page %"Z"u",
+ DPRINTF(("committing txn %"Y"u %p on mdbenv %p, root page %"Y"u",
txn->mt_txnid, (void*)txn, (void*)env, txn->mt_dbs[MAIN_DBI].md_root));
/* Update DB root pointers */
p = (MDB_page *)&pbuf;
if (!F_ISSET(p->mp_flags, P_META)) {
- DPRINTF(("page %"Z"u not a meta page", p->mp_pgno));
+ DPRINTF(("page %"Y"u not a meta page", p->mp_pgno));
return MDB_INVALID;
}
MDB_env *env;
MDB_meta meta, metab, *mp;
unsigned flags;
- size_t mapsize;
+ mdb_size_t mapsize;
off_t off;
int rc, len, toggle;
char *ptr;
#endif
toggle = txn->mt_txnid & 1;
- DPRINTF(("writing meta page %d for root page %"Z"u",
+ DPRINTF(("writing meta page %d for root page %"Y"u",
toggle, txn->mt_dbs[MAIN_DBI].md_root));
env = txn->mt_env;
int access = SECTION_MAP_READ;
HANDLE mh;
void *map;
- size_t msize;
+ SIZE_T msize;
ULONG pageprot = PAGE_READONLY, secprot, alloctype;
if (flags & MDB_WRITEMAP) {
}
int ESECT
-mdb_env_set_mapsize(MDB_env *env, size_t size)
+mdb_env_set_mapsize(MDB_env *env, mdb_size_t size)
{
/* If env is already open, caller is responsible for making
* sure there are no active txns.
}
static int ESECT
-mdb_fsize(HANDLE fd, size_t *size)
+mdb_fsize(HANDLE fd, mdb_size_t *size)
{
#ifdef _WIN32
LARGE_INTEGER fsize;
/* Make sure mapsize >= committed data size. Even when using
* mm_mapsize, which could be broken in old files (ITS#7789).
*/
- size_t minsize = (meta.mm_last_pg + 1) * meta.mm_psize;
+ mdb_size_t minsize = (meta.mm_last_pg + 1) * meta.mm_psize;
if (env->me_mapsize < minsize)
env->me_mapsize = minsize;
}
meta->mm_version, env->me_psize));
DPRINTF(("using meta page %d", (int) (meta->mm_txnid & 1)));
DPRINTF(("depth: %u", db->md_depth));
- DPRINTF(("entries: %"Z"u", db->md_entries));
- DPRINTF(("branch pages: %"Z"u", db->md_branch_pages));
- DPRINTF(("leaf pages: %"Z"u", db->md_leaf_pages));
- DPRINTF(("overflow pages: %"Z"u", db->md_overflow_pages));
- DPRINTF(("root: %"Z"u", db->md_root));
+ DPRINTF(("entries: %"Y"u", db->md_entries));
+ DPRINTF(("branch pages: %"Y"u", db->md_branch_pages));
+ DPRINTF(("leaf pages: %"Y"u", db->md_leaf_pages));
+ DPRINTF(("overflow pages: %"Y"u", db->md_overflow_pages));
+ DPRINTF(("root: %"Y"u", db->md_root));
}
#endif
free(env);
}
-/** Compare two items pointing at aligned size_t's */
+/** Compare two items pointing at aligned mdb_size_t's */
static int
mdb_cmp_long(const MDB_val *a, const MDB_val *b)
{
- return (*(size_t *)a->mv_data < *(size_t *)b->mv_data) ? -1 :
- *(size_t *)a->mv_data > *(size_t *)b->mv_data;
+ return (*(mdb_size_t *)a->mv_data < *(mdb_size_t *)b->mv_data) ? -1 :
+ *(mdb_size_t *)a->mv_data > *(mdb_size_t *)b->mv_data;
}
/** Compare two items pointing at aligned unsigned int's.
*
* This is also set as #MDB_INTEGERDUP|#MDB_DUPFIXED's #MDB_dbx.%md_dcmp,
- * but #mdb_cmp_clong() is called instead if the data type is size_t.
+ * but #mdb_cmp_clong() is called instead if the data type is mdb_size_t.
*/
static int
mdb_cmp_int(const MDB_val *a, const MDB_val *b)
nkeys = NUMKEYS(mp);
- DPRINTF(("searching %u keys in %s %spage %"Z"u",
+ DPRINTF(("searching %u keys in %s %spage %"Y"u",
nkeys, IS_LEAF(mp) ? "leaf" : "branch", IS_SUBP(mp) ? "sub-" : "",
mdb_dbg_pgno(mp)));
* alignment is guaranteed. Use faster mdb_cmp_int.
*/
if (cmp == mdb_cmp_cint && IS_BRANCH(mp)) {
- if (NODEPTR(mp, 1)->mn_ksize == sizeof(size_t))
+ if (NODEPTR(mp, 1)->mn_ksize == sizeof(mdb_size_t))
cmp = mdb_cmp_long;
else
cmp = mdb_cmp_int;
DPRINTF(("found leaf index %u [%s], rc = %i",
i, DKEY(&nodekey), rc));
else
- DPRINTF(("found branch index %u [%s -> %"Z"u], rc = %i",
+ DPRINTF(("found branch index %u [%s -> %"Y"u], rc = %i",
i, DKEY(&nodekey), NODEPGNO(node), rc));
#endif
if (rc == 0)
mdb_cursor_pop(MDB_cursor *mc)
{
if (mc->mc_snum) {
- DPRINTF(("popping page %"Z"u off db %d cursor %p",
+ DPRINTF(("popping page %"Y"u off db %d cursor %p",
mc->mc_pg[mc->mc_top]->mp_pgno, DDBI(mc), (void *) mc));
mc->mc_snum--;
static int
mdb_cursor_push(MDB_cursor *mc, MDB_page *mp)
{
- DPRINTF(("pushing page %"Z"u on db %d cursor %p", mp->mp_pgno,
+ DPRINTF(("pushing page %"Y"u on db %d cursor %p", mp->mp_pgno,
DDBI(mc), (void *) mc));
if (mc->mc_snum >= CURSOR_STACK) {
level = 0;
p = (MDB_page *)(env->me_map + env->me_psize * pgno);
} else {
- DPRINTF(("page %"Z"u not found", pgno));
+ DPRINTF(("page %"Y"u not found", pgno));
txn->mt_flags |= MDB_TXN_ERROR;
return MDB_PAGE_NOTFOUND;
}
MDB_node *node;
indx_t i;
- DPRINTF(("branch page %"Z"u has %u keys", mp->mp_pgno, NUMKEYS(mp)));
+ DPRINTF(("branch page %"Y"u has %u keys", mp->mp_pgno, NUMKEYS(mp)));
/* Don't assert on branch pages in the FreeDB. We can get here
* while in the process of rebalancing a FreeDB branch page; we must
* let that proceed. ITS#8336
*/
mdb_cassert(mc, !mc->mc_dbi || NUMKEYS(mp) > 1);
- DPRINTF(("found index 0 to page %"Z"u", NODEPGNO(NODEPTR(mp, 0))));
+ DPRINTF(("found index 0 to page %"Y"u", NODEPGNO(NODEPTR(mp, 0))));
if (flags & (MDB_PS_FIRST|MDB_PS_LAST)) {
i = 0;
return MDB_CORRUPTED;
}
- DPRINTF(("found leaf page %"Z"u for key [%s]", mp->mp_pgno,
+ DPRINTF(("found leaf page %"Y"u for key [%s]", mp->mp_pgno,
key ? DKEY(key) : "null"));
mc->mc_flags |= C_INITIALIZED;
mc->mc_flags &= ~C_EOF;
mc->mc_snum = 1;
mc->mc_top = 0;
- DPRINTF(("db %d root page %"Z"u has flags 0x%X",
+ DPRINTF(("db %d root page %"Y"u has flags 0x%X",
DDBI(mc), root, mc->mc_pg[0]->mp_flags));
if (flags & MDB_PS_MODIFY) {
MDB_ID pn = pg << 1;
int rc;
- DPRINTF(("free ov page %"Z"u (%d)", pg, ovpages));
+ DPRINTF(("free ov page %"Y"u (%d)", pg, ovpages));
/* If the page is dirty or on the spill list we just acquired it,
* so we should give it back to our current free list, if any.
* Otherwise put it onto the list of pages we freed in this txn.
data->mv_size = NODEDSZ(leaf);
memcpy(&pgno, NODEDATA(leaf), sizeof(pgno));
if ((rc = mdb_page_get(txn, pgno, &omp, NULL)) != 0) {
- DPRINTF(("read overflow page %"Z"u failed", pgno));
+ DPRINTF(("read overflow page %"Y"u failed", pgno));
return rc;
}
data->mv_data = METADATA(omp);
}
mdb_cursor_pop(mc);
- DPRINTF(("parent page is page %"Z"u, index %u",
+ DPRINTF(("parent page is page %"Y"u, index %u",
mc->mc_pg[mc->mc_top]->mp_pgno, mc->mc_ki[mc->mc_top]));
if (move_right ? (mc->mc_ki[mc->mc_top] + 1u >= NUMKEYS(mc->mc_pg[mc->mc_top]))
}
}
- DPRINTF(("cursor_next: top page is %"Z"u in cursor %p",
+ DPRINTF(("cursor_next: top page is %"Y"u in cursor %p",
mdb_dbg_pgno(mp), (void *) mc));
if (mc->mc_flags & C_DEL)
goto skip;
return rc;
}
mp = mc->mc_pg[mc->mc_top];
- DPRINTF(("next page is %"Z"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
+ DPRINTF(("next page is %"Y"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
} else
mc->mc_ki[mc->mc_top]++;
skip:
- DPRINTF(("==> cursor points to page %"Z"u with %u keys, key index %u",
+ DPRINTF(("==> cursor points to page %"Y"u with %u keys, key index %u",
mdb_dbg_pgno(mp), NUMKEYS(mp), mc->mc_ki[mc->mc_top]));
if (IS_LEAF2(mp)) {
}
}
- DPRINTF(("cursor_prev: top page is %"Z"u in cursor %p",
+ DPRINTF(("cursor_prev: top page is %"Y"u in cursor %p",
mdb_dbg_pgno(mp), (void *) mc));
if (mc->mc_ki[mc->mc_top] == 0) {
}
mp = mc->mc_pg[mc->mc_top];
mc->mc_ki[mc->mc_top] = NUMKEYS(mp) - 1;
- DPRINTF(("prev page is %"Z"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
+ DPRINTF(("prev page is %"Y"u, key index %u", mp->mp_pgno, mc->mc_ki[mc->mc_top]));
} else
mc->mc_ki[mc->mc_top]--;
mc->mc_flags &= ~C_EOF;
- DPRINTF(("==> cursor points to page %"Z"u with %u keys, key index %u",
+ DPRINTF(("==> cursor points to page %"Y"u with %u keys, key index %u",
mdb_dbg_pgno(mp), NUMKEYS(mp), mc->mc_ki[mc->mc_top]));
if (IS_LEAF2(mp)) {
if ((rc = mdb_node_read(mc->mc_txn, leaf, &olddata)) != MDB_SUCCESS)
return rc;
dcmp = mc->mc_dbx->md_dcmp;
-#if UINT_MAX < SIZE_MAX
- if (dcmp == mdb_cmp_int && olddata.mv_size == sizeof(size_t))
+#if UINT_MAX < SIZE_MAX || defined(MDB_VL32)
+ if (dcmp == mdb_cmp_int && olddata.mv_size == sizeof(mdb_size_t))
dcmp = mdb_cmp_clong;
#endif
rc = dcmp(data, &olddata);
if (flags == MDB_CURRENT)
goto current;
dcmp = mc->mc_dbx->md_dcmp;
-#if UINT_MAX < SIZE_MAX
- if (dcmp == mdb_cmp_int && olddata.mv_size == sizeof(size_t))
+#if UINT_MAX < SIZE_MAX || defined(MDB_VL32)
+ if (dcmp == mdb_cmp_int && olddata.mv_size == sizeof(mdb_size_t))
dcmp = mdb_cmp_clong;
#endif
/* does data match? */
if ((rc = mdb_page_alloc(mc, num, &np)))
return rc;
- DPRINTF(("allocated new mpage %"Z"u, page size %u",
+ DPRINTF(("allocated new mpage %"Y"u, page size %u",
np->mp_pgno, mc->mc_txn->mt_env->me_psize));
np->mp_flags = flags | P_DIRTY;
np->mp_lower = (PAGEHDRSZ-PAGEBASE);
mdb_cassert(mc, mp->mp_upper >= mp->mp_lower);
- DPRINTF(("add to %s %spage %"Z"u index %i, data size %"Z"u key size %"Z"u [%s]",
+ DPRINTF(("add to %s %spage %"Y"u index %i, data size %"Z"u key size %"Z"u [%s]",
IS_LEAF(mp) ? "leaf" : "branch",
IS_SUBP(mp) ? "sub-" : "",
mdb_dbg_pgno(mp), indx, data ? data->mv_size : 0,
goto full;
if ((rc = mdb_page_new(mc, P_OVERFLOW, ovpages, &ofp)))
return rc;
- DPRINTF(("allocated overflow page %"Z"u", ofp->mp_pgno));
+ DPRINTF(("allocated overflow page %"Y"u", ofp->mp_pgno));
flags |= F_BIGDATA;
goto update;
} else {
return MDB_SUCCESS;
full:
- DPRINTF(("not enough room in page %"Z"u, got %u ptrs",
+ DPRINTF(("not enough room in page %"Y"u, got %u ptrs",
mdb_dbg_pgno(mp), NUMKEYS(mp)));
DPRINTF(("upper-lower = %u - %u = %"Z"d", mp->mp_upper,mp->mp_lower,room));
DPRINTF(("node size = %"Z"u", node_size));
MDB_node *node;
char *base;
- DPRINTF(("delete node %u on %s page %"Z"u", indx,
+ DPRINTF(("delete node %u on %s page %"Y"u", indx,
IS_LEAF(mp) ? "leaf" : "branch", mdb_dbg_pgno(mp)));
numkeys = NUMKEYS(mp);
mdb_cassert(mc, indx < numkeys);
mx->mx_db.md_flags |= MDB_INTEGERKEY;
}
}
- DPRINTF(("Sub-db -%u root page %"Z"u", mx->mx_cursor.mc_dbi,
+ DPRINTF(("Sub-db -%u root page %"Y"u", mx->mx_cursor.mc_dbi,
mx->mx_db.md_root));
mx->mx_dbflag = DB_VALID|DB_USRVALID|DB_DIRTY; /* DB_DIRTY guides mdb_cursor_touch */
-#if UINT_MAX < SIZE_MAX
- if (mx->mx_dbx.md_cmp == mdb_cmp_int && mx->mx_db.md_pad == sizeof(size_t))
+#if UINT_MAX < SIZE_MAX || defined(MDB_VL32)
+ if (mx->mx_dbx.md_cmp == mdb_cmp_int && mx->mx_db.md_pad == sizeof(mdb_size_t))
mx->mx_dbx.md_cmp = mdb_cmp_clong;
#endif
}
}
mx->mx_db = src_mx->mx_db;
mx->mx_cursor.mc_pg[0] = src_mx->mx_cursor.mc_pg[0];
- DPRINTF(("Sub-db -%u root page %"Z"u", mx->mx_cursor.mc_dbi,
+ DPRINTF(("Sub-db -%u root page %"Y"u", mx->mx_cursor.mc_dbi,
mx->mx_db.md_root));
}
char kbuf2[DKBUF_MAXKEYSIZE*2+1];
k2.mv_data = NODEKEY(node);
k2.mv_size = node->mn_ksize;
- DPRINTF(("update key %u (ofs %u) [%s] to [%s] on page %"Z"u",
+ DPRINTF(("update key %u (ofs %u) [%s] to [%s] on page %"Y"u",
indx, ptr,
mdb_dkey(&k2, kbuf2),
DKEY(key),
return rc;
}
- DPRINTF(("moving %s node %u [%s] on page %"Z"u to node %u on page %"Z"u",
+ DPRINTF(("moving %s node %u [%s] on page %"Y"u to node %u on page %"Y"u",
IS_LEAF(csrc->mc_pg[csrc->mc_top]) ? "leaf" : "branch",
csrc->mc_ki[csrc->mc_top],
DKEY(&key),
key.mv_size = NODEKSZ(srcnode);
key.mv_data = NODEKEY(srcnode);
}
- DPRINTF(("update separator for source page %"Z"u to [%s]",
+ DPRINTF(("update separator for source page %"Y"u to [%s]",
csrc->mc_pg[csrc->mc_top]->mp_pgno, DKEY(&key)));
mdb_cursor_copy(csrc, &mn);
mn.mc_snum--;
key.mv_size = NODEKSZ(srcnode);
key.mv_data = NODEKEY(srcnode);
}
- DPRINTF(("update separator for destination page %"Z"u to [%s]",
+ DPRINTF(("update separator for destination page %"Y"u to [%s]",
cdst->mc_pg[cdst->mc_top]->mp_pgno, DKEY(&key)));
mdb_cursor_copy(cdst, &mn);
mn.mc_snum--;
psrc = csrc->mc_pg[csrc->mc_top];
pdst = cdst->mc_pg[cdst->mc_top];
- DPRINTF(("merging page %"Z"u into %"Z"u", psrc->mp_pgno, pdst->mp_pgno));
+ DPRINTF(("merging page %"Y"u into %"Y"u", psrc->mp_pgno, pdst->mp_pgno));
mdb_cassert(csrc, csrc->mc_snum > 1); /* can't merge root page */
mdb_cassert(csrc, cdst->mc_snum > 1);
}
}
- DPRINTF(("dst page %"Z"u now has %u keys (%.1f%% filled)",
+ DPRINTF(("dst page %"Y"u now has %u keys (%.1f%% filled)",
pdst->mp_pgno, NUMKEYS(pdst),
(float)PAGEFILL(cdst->mc_txn->mt_env, pdst) / 10));
minkeys = 1;
thresh = FILL_THRESHOLD;
}
- DPRINTF(("rebalancing %s page %"Z"u (has %u keys, %.1f%% full)",
+ DPRINTF(("rebalancing %s page %"Y"u (has %u keys, %.1f%% full)",
IS_LEAF(mc->mc_pg[mc->mc_top]) ? "leaf" : "branch",
mdb_dbg_pgno(mc->mc_pg[mc->mc_top]), NUMKEYS(mc->mc_pg[mc->mc_top]),
(float)PAGEFILL(mc->mc_txn->mt_env, mc->mc_pg[mc->mc_top]) / 10));
if (PAGEFILL(mc->mc_txn->mt_env, mc->mc_pg[mc->mc_top]) >= thresh &&
NUMKEYS(mc->mc_pg[mc->mc_top]) >= minkeys) {
- DPRINTF(("no need to rebalance page %"Z"u, above fill threshold",
+ DPRINTF(("no need to rebalance page %"Y"u, above fill threshold",
mdb_dbg_pgno(mc->mc_pg[mc->mc_top])));
return MDB_SUCCESS;
}
fromleft = 1;
}
- DPRINTF(("found neighbor page %"Z"u (%u keys, %.1f%% full)",
+ DPRINTF(("found neighbor page %"Y"u (%u keys, %.1f%% full)",
mn.mc_pg[mn.mc_top]->mp_pgno, NUMKEYS(mn.mc_pg[mn.mc_top]),
(float)PAGEFILL(mc->mc_txn->mt_env, mn.mc_pg[mn.mc_top]) / 10));
newindx = mc->mc_ki[mc->mc_top];
nkeys = NUMKEYS(mp);
- DPRINTF(("-----> splitting %s page %"Z"u and adding [%s] at index %i/%i",
+ DPRINTF(("-----> splitting %s page %"Y"u and adding [%s] at index %i/%i",
IS_LEAF(mp) ? "leaf" : "branch", mp->mp_pgno,
DKEY(newkey), mc->mc_ki[mc->mc_top], nkeys));
if ((rc = mdb_page_new(mc, mp->mp_flags, 1, &rp)))
return rc;
rp->mp_pad = mp->mp_pad;
- DPRINTF(("new right sibling: page %"Z"u", rp->mp_pgno));
+ DPRINTF(("new right sibling: page %"Y"u", rp->mp_pgno));
/* Usually when splitting the root page, the cursor
* height is 1. But when called from mdb_update_key,
mc->mc_pg[0] = pp;
mc->mc_ki[0] = 0;
mc->mc_db->md_root = pp->mp_pgno;
- DPRINTF(("root split! new root = %"Z"u", pp->mp_pgno));
+ DPRINTF(("root split! new root = %"Y"u", pp->mp_pgno));
new_root = mc->mc_db->md_depth++;
/* Add left (implicit) pointer. */
ptop = 0;
} else {
ptop = mc->mc_top-1;
- DPRINTF(("parent branch page is %"Z"u", mc->mc_pg[ptop]->mp_pgno));
+ DPRINTF(("parent branch page is %"Y"u", mc->mc_pg[ptop]->mp_pgno));
}
mdb_cursor_copy(mc, &mn);
w2 = txn->mt_next_pgno * env->me_psize;
{
- size_t fsize = 0;
+ mdb_size_t fsize = 0;
if ((rc = mdb_fsize(env->me_fd, &fsize)))
goto leave;
if (w2 > fsize)
if (mr[i].mr_pid) {
txnid_t txnid = mr[i].mr_txnid;
sprintf(buf, txnid == (txnid_t)-1 ?
- "%10d %"Z"x -\n" : "%10d %"Z"x %"Z"u\n",
+ "%10d %"Z"x -\n" : "%10d %"Z"x %"Y"u\n",
(int)mr[i].mr_pid, (size_t)mr[i].mr_tid, txnid);
if (first) {
first = 0;
}
for (; j<rdrs; j++)
if (mr[j].mr_pid == pid) {
- DPRINTF(("clear stale reader pid %u txn %"Z"d",
+ DPRINTF(("clear stale reader pid %u txn %"Y"d",
(unsigned) pid, mr[j].mr_txnid));
mr[j].mr_pid = 0;
count++;
projects / openldap / blobdiff