mirror of
https://github.com/isar/libmdbx.git
synced 2025-01-30 22:47:16 +08:00
544 lines
18 KiB
C
544 lines
18 KiB
C
/// \copyright SPDX-License-Identifier: Apache-2.0
|
|
/// \author Леонид Юрьев aka Leonid Yuriev <leo@yuriev.ru> \date 2015-2025
|
|
|
|
#include "internals.h"
|
|
|
|
__cold size_t mdbx_default_pagesize(void) {
|
|
size_t pagesize = globals.sys_pagesize;
|
|
ENSURE(nullptr, is_powerof2(pagesize));
|
|
pagesize = (pagesize >= MDBX_MIN_PAGESIZE) ? pagesize : MDBX_MIN_PAGESIZE;
|
|
pagesize = (pagesize <= MDBX_MAX_PAGESIZE) ? pagesize : MDBX_MAX_PAGESIZE;
|
|
return pagesize;
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_dbsize_min(intptr_t pagesize) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
else if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
return MIN_PAGENO * pagesize;
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_dbsize_max(intptr_t pagesize) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
else if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
STATIC_ASSERT(MAX_MAPSIZE < INTPTR_MAX);
|
|
const uint64_t limit = (1 + (uint64_t)MAX_PAGENO) * pagesize;
|
|
return (limit < MAX_MAPSIZE) ? (intptr_t)limit : (intptr_t)MAX_MAPSIZE;
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_txnsize_max(intptr_t pagesize) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
else if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
STATIC_ASSERT(MAX_MAPSIZE < INTPTR_MAX);
|
|
const uint64_t pgl_limit = pagesize * (uint64_t)(PAGELIST_LIMIT / MDBX_GOLD_RATIO_DBL);
|
|
const uint64_t map_limit = (uint64_t)(MAX_MAPSIZE / MDBX_GOLD_RATIO_DBL);
|
|
return (pgl_limit < map_limit) ? (intptr_t)pgl_limit : (intptr_t)map_limit;
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_keysize_max(intptr_t pagesize, MDBX_db_flags_t flags) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
return keysize_max(pagesize, flags);
|
|
}
|
|
|
|
__cold int mdbx_env_get_maxkeysize_ex(const MDBX_env *env, MDBX_db_flags_t flags) {
|
|
if (unlikely(!env || env->signature.weak != env_signature))
|
|
return -1;
|
|
|
|
return (int)mdbx_limits_keysize_max((intptr_t)env->ps, flags);
|
|
}
|
|
|
|
__cold int mdbx_env_get_maxkeysize(const MDBX_env *env) { return mdbx_env_get_maxkeysize_ex(env, MDBX_DUPSORT); }
|
|
|
|
__cold intptr_t mdbx_limits_keysize_min(MDBX_db_flags_t flags) { return keysize_min(flags); }
|
|
|
|
__cold intptr_t mdbx_limits_valsize_max(intptr_t pagesize, MDBX_db_flags_t flags) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
return valsize_max(pagesize, flags);
|
|
}
|
|
|
|
__cold int mdbx_env_get_maxvalsize_ex(const MDBX_env *env, MDBX_db_flags_t flags) {
|
|
if (unlikely(!env || env->signature.weak != env_signature))
|
|
return -1;
|
|
|
|
return (int)mdbx_limits_valsize_max((intptr_t)env->ps, flags);
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_valsize_min(MDBX_db_flags_t flags) { return valsize_min(flags); }
|
|
|
|
__cold intptr_t mdbx_limits_pairsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
if (flags & (MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP | MDBX_REVERSEDUP))
|
|
return BRANCH_NODE_MAX(pagesize) - NODESIZE;
|
|
|
|
return LEAF_NODE_MAX(pagesize) - NODESIZE;
|
|
}
|
|
|
|
__cold int mdbx_env_get_pairsize4page_max(const MDBX_env *env, MDBX_db_flags_t flags) {
|
|
if (unlikely(!env || env->signature.weak != env_signature))
|
|
return -1;
|
|
|
|
return (int)mdbx_limits_pairsize4page_max((intptr_t)env->ps, flags);
|
|
}
|
|
|
|
__cold intptr_t mdbx_limits_valsize4page_max(intptr_t pagesize, MDBX_db_flags_t flags) {
|
|
if (pagesize < 1)
|
|
pagesize = (intptr_t)mdbx_default_pagesize();
|
|
if (unlikely(pagesize < (intptr_t)MDBX_MIN_PAGESIZE || pagesize > (intptr_t)MDBX_MAX_PAGESIZE ||
|
|
!is_powerof2((size_t)pagesize)))
|
|
return -1;
|
|
|
|
if (flags & (MDBX_DUPSORT | MDBX_DUPFIXED | MDBX_INTEGERDUP | MDBX_REVERSEDUP))
|
|
return valsize_max(pagesize, flags);
|
|
|
|
return PAGESPACE(pagesize);
|
|
}
|
|
|
|
__cold int mdbx_env_get_valsize4page_max(const MDBX_env *env, MDBX_db_flags_t flags) {
|
|
if (unlikely(!env || env->signature.weak != env_signature))
|
|
return -1;
|
|
|
|
return (int)mdbx_limits_valsize4page_max((intptr_t)env->ps, flags);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
static size_t estimate_rss(size_t database_bytes) {
|
|
return database_bytes + database_bytes / 64 + (512 + MDBX_WORDBITS * 16) * MEGABYTE;
|
|
}
|
|
|
|
__cold int mdbx_env_warmup(const MDBX_env *env, const MDBX_txn *txn, MDBX_warmup_flags_t flags,
|
|
unsigned timeout_seconds_16dot16) {
|
|
if (unlikely(env == nullptr && txn == nullptr))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
if (unlikely(flags > (MDBX_warmup_force | MDBX_warmup_oomsafe | MDBX_warmup_lock | MDBX_warmup_touchlimit |
|
|
MDBX_warmup_release)))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
|
|
if (txn) {
|
|
int err = check_txn(txn, MDBX_TXN_BLOCKED - MDBX_TXN_ERROR);
|
|
if (unlikely(err != MDBX_SUCCESS))
|
|
return LOG_IFERR(err);
|
|
}
|
|
if (env) {
|
|
int err = check_env(env, false);
|
|
if (unlikely(err != MDBX_SUCCESS))
|
|
return LOG_IFERR(err);
|
|
if (txn && unlikely(txn->env != env))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
} else {
|
|
env = txn->env;
|
|
}
|
|
|
|
const uint64_t timeout_monotime = (timeout_seconds_16dot16 && (flags & MDBX_warmup_force))
|
|
? osal_monotime() + osal_16dot16_to_monotime(timeout_seconds_16dot16)
|
|
: 0;
|
|
|
|
if (flags & MDBX_warmup_release)
|
|
munlock_all(env);
|
|
|
|
pgno_t used_pgno;
|
|
if (txn) {
|
|
used_pgno = txn->geo.first_unallocated;
|
|
} else {
|
|
const troika_t troika = meta_tap(env);
|
|
used_pgno = meta_recent(env, &troika).ptr_v->geometry.first_unallocated;
|
|
}
|
|
const size_t used_range = pgno_align2os_bytes(env, used_pgno);
|
|
const pgno_t mlock_pgno = bytes2pgno(env, used_range);
|
|
|
|
int rc = MDBX_SUCCESS;
|
|
if (flags & MDBX_warmup_touchlimit) {
|
|
const size_t estimated_rss = estimate_rss(used_range);
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
SIZE_T current_ws_lower, current_ws_upper;
|
|
if (GetProcessWorkingSetSize(GetCurrentProcess(), ¤t_ws_lower, ¤t_ws_upper) &&
|
|
current_ws_lower < estimated_rss) {
|
|
const SIZE_T ws_lower = estimated_rss;
|
|
const SIZE_T ws_upper =
|
|
(MDBX_WORDBITS == 32 && ws_lower > MEGABYTE * 2048) ? ws_lower : ws_lower + MDBX_WORDBITS * MEGABYTE * 32;
|
|
if (!SetProcessWorkingSetSize(GetCurrentProcess(), ws_lower, ws_upper)) {
|
|
rc = (int)GetLastError();
|
|
WARNING("SetProcessWorkingSetSize(%zu, %zu) error %d", ws_lower, ws_upper, rc);
|
|
}
|
|
}
|
|
#endif /* Windows */
|
|
#ifdef RLIMIT_RSS
|
|
struct rlimit rss;
|
|
if (getrlimit(RLIMIT_RSS, &rss) == 0 && rss.rlim_cur < estimated_rss) {
|
|
rss.rlim_cur = estimated_rss;
|
|
if (rss.rlim_max < estimated_rss)
|
|
rss.rlim_max = estimated_rss;
|
|
if (setrlimit(RLIMIT_RSS, &rss)) {
|
|
rc = errno;
|
|
WARNING("setrlimit(%s, {%zu, %zu}) error %d", "RLIMIT_RSS", (size_t)rss.rlim_cur, (size_t)rss.rlim_max, rc);
|
|
}
|
|
}
|
|
#endif /* RLIMIT_RSS */
|
|
#ifdef RLIMIT_MEMLOCK
|
|
if (flags & MDBX_warmup_lock) {
|
|
struct rlimit memlock;
|
|
if (getrlimit(RLIMIT_MEMLOCK, &memlock) == 0 && memlock.rlim_cur < estimated_rss) {
|
|
memlock.rlim_cur = estimated_rss;
|
|
if (memlock.rlim_max < estimated_rss)
|
|
memlock.rlim_max = estimated_rss;
|
|
if (setrlimit(RLIMIT_MEMLOCK, &memlock)) {
|
|
rc = errno;
|
|
WARNING("setrlimit(%s, {%zu, %zu}) error %d", "RLIMIT_MEMLOCK", (size_t)memlock.rlim_cur,
|
|
(size_t)memlock.rlim_max, rc);
|
|
}
|
|
}
|
|
}
|
|
#endif /* RLIMIT_MEMLOCK */
|
|
(void)estimated_rss;
|
|
}
|
|
|
|
#if defined(MLOCK_ONFAULT) && \
|
|
((defined(_GNU_SOURCE) && __GLIBC_PREREQ(2, 27)) || (defined(__ANDROID_API__) && __ANDROID_API__ >= 30)) && \
|
|
(defined(__linux__) || defined(__gnu_linux__))
|
|
if ((flags & MDBX_warmup_lock) != 0 && globals.linux_kernel_version >= 0x04040000 &&
|
|
atomic_load32(&env->mlocked_pgno, mo_AcquireRelease) < mlock_pgno) {
|
|
if (mlock2(env->dxb_mmap.base, used_range, MLOCK_ONFAULT)) {
|
|
rc = errno;
|
|
WARNING("mlock2(%zu, %s) error %d", used_range, "MLOCK_ONFAULT", rc);
|
|
} else {
|
|
update_mlcnt(env, mlock_pgno, true);
|
|
rc = MDBX_SUCCESS;
|
|
}
|
|
if (rc != EINVAL)
|
|
flags -= MDBX_warmup_lock;
|
|
}
|
|
#endif /* MLOCK_ONFAULT */
|
|
|
|
int err = MDBX_ENOSYS;
|
|
err = dxb_set_readahead(env, used_pgno, true, true);
|
|
if (err != MDBX_SUCCESS && rc == MDBX_SUCCESS)
|
|
rc = err;
|
|
|
|
if ((flags & MDBX_warmup_force) != 0 && (rc == MDBX_SUCCESS || rc == MDBX_ENOSYS)) {
|
|
const volatile uint8_t *ptr = env->dxb_mmap.base;
|
|
size_t offset = 0, unused = 42;
|
|
#if !(defined(_WIN32) || defined(_WIN64))
|
|
if (flags & MDBX_warmup_oomsafe) {
|
|
const int null_fd = open("/dev/null", O_WRONLY);
|
|
if (unlikely(null_fd < 0))
|
|
rc = errno;
|
|
else {
|
|
struct iovec iov[MDBX_AUXILARY_IOV_MAX];
|
|
for (;;) {
|
|
unsigned i;
|
|
for (i = 0; i < MDBX_AUXILARY_IOV_MAX && offset < used_range; ++i) {
|
|
iov[i].iov_base = (void *)(ptr + offset);
|
|
iov[i].iov_len = 1;
|
|
offset += globals.sys_pagesize;
|
|
}
|
|
if (unlikely(writev(null_fd, iov, i) < 0)) {
|
|
rc = errno;
|
|
if (rc == EFAULT)
|
|
rc = ENOMEM;
|
|
break;
|
|
}
|
|
if (offset >= used_range) {
|
|
rc = MDBX_SUCCESS;
|
|
break;
|
|
}
|
|
if (timeout_seconds_16dot16 && osal_monotime() > timeout_monotime) {
|
|
rc = MDBX_RESULT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
close(null_fd);
|
|
}
|
|
} else
|
|
#endif /* Windows */
|
|
for (;;) {
|
|
unused += ptr[offset];
|
|
offset += globals.sys_pagesize;
|
|
if (offset >= used_range) {
|
|
rc = MDBX_SUCCESS;
|
|
break;
|
|
}
|
|
if (timeout_seconds_16dot16 && osal_monotime() > timeout_monotime) {
|
|
rc = MDBX_RESULT_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
(void)unused;
|
|
}
|
|
|
|
if ((flags & MDBX_warmup_lock) != 0 && (rc == MDBX_SUCCESS || rc == MDBX_ENOSYS) &&
|
|
atomic_load32(&env->mlocked_pgno, mo_AcquireRelease) < mlock_pgno) {
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
if (VirtualLock(env->dxb_mmap.base, used_range)) {
|
|
update_mlcnt(env, mlock_pgno, true);
|
|
rc = MDBX_SUCCESS;
|
|
} else {
|
|
rc = (int)GetLastError();
|
|
WARNING("%s(%zu) error %d", "VirtualLock", used_range, rc);
|
|
}
|
|
#elif defined(_POSIX_MEMLOCK_RANGE)
|
|
if (mlock(env->dxb_mmap.base, used_range) == 0) {
|
|
update_mlcnt(env, mlock_pgno, true);
|
|
rc = MDBX_SUCCESS;
|
|
} else {
|
|
rc = errno;
|
|
WARNING("%s(%zu) error %d", "mlock", used_range, rc);
|
|
}
|
|
#else
|
|
rc = MDBX_ENOSYS;
|
|
#endif
|
|
}
|
|
|
|
return LOG_IFERR(rc);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------*/
|
|
|
|
__cold int mdbx_env_get_fd(const MDBX_env *env, mdbx_filehandle_t *arg) {
|
|
int rc = check_env(env, true);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
if (unlikely(!arg))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
|
|
*arg = env->lazy_fd;
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
__cold int mdbx_env_set_flags(MDBX_env *env, MDBX_env_flags_t flags, bool onoff) {
|
|
int rc = check_env(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
if (unlikely(flags & ((env->flags & ENV_ACTIVE) ? ~ENV_CHANGEABLE_FLAGS : ~ENV_USABLE_FLAGS)))
|
|
return LOG_IFERR(MDBX_EPERM);
|
|
|
|
if (unlikely(env->flags & MDBX_RDONLY))
|
|
return LOG_IFERR(MDBX_EACCESS);
|
|
|
|
const bool lock_needed = (env->flags & ENV_ACTIVE) && !env_txn0_owned(env);
|
|
bool should_unlock = false;
|
|
if (lock_needed) {
|
|
rc = lck_txn_lock(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
should_unlock = true;
|
|
}
|
|
|
|
if (onoff)
|
|
env->flags = combine_durability_flags(env->flags, flags);
|
|
else
|
|
env->flags &= ~flags;
|
|
|
|
if (should_unlock)
|
|
lck_txn_unlock(env);
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
__cold int mdbx_env_get_flags(const MDBX_env *env, unsigned *flags) {
|
|
int rc = check_env(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
if (unlikely(!flags))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
|
|
*flags = env->flags & ENV_USABLE_FLAGS;
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
__cold int mdbx_env_set_userctx(MDBX_env *env, void *ctx) {
|
|
int rc = check_env(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
env->userctx = ctx;
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
__cold void *mdbx_env_get_userctx(const MDBX_env *env) { return env ? env->userctx : nullptr; }
|
|
|
|
__cold int mdbx_env_set_assert(MDBX_env *env, MDBX_assert_func *func) {
|
|
int rc = check_env(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
#if MDBX_DEBUG
|
|
env->assert_func = func;
|
|
return MDBX_SUCCESS;
|
|
#else
|
|
(void)func;
|
|
return LOG_IFERR(MDBX_ENOSYS);
|
|
#endif
|
|
}
|
|
|
|
__cold int mdbx_env_set_hsr(MDBX_env *env, MDBX_hsr_func *hsr) {
|
|
int rc = check_env(env, false);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
env->hsr_callback = hsr;
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
__cold MDBX_hsr_func *mdbx_env_get_hsr(const MDBX_env *env) {
|
|
return likely(env && env->signature.weak == env_signature) ? env->hsr_callback : nullptr;
|
|
}
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
__cold int mdbx_env_get_pathW(const MDBX_env *env, const wchar_t **arg) {
|
|
int rc = check_env(env, true);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
if (unlikely(!arg))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
|
|
*arg = env->pathname.specified;
|
|
return MDBX_SUCCESS;
|
|
}
|
|
#endif /* Windows */
|
|
|
|
__cold int mdbx_env_get_path(const MDBX_env *env, const char **arg) {
|
|
int rc = check_env(env, true);
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
if (unlikely(!arg))
|
|
return LOG_IFERR(MDBX_EINVAL);
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
if (!env->pathname_char) {
|
|
*arg = nullptr;
|
|
DWORD flags = /* WC_ERR_INVALID_CHARS */ 0x80;
|
|
size_t mb_len =
|
|
WideCharToMultiByte(CP_THREAD_ACP, flags, env->pathname.specified, -1, nullptr, 0, nullptr, nullptr);
|
|
rc = mb_len ? MDBX_SUCCESS : (int)GetLastError();
|
|
if (rc == ERROR_INVALID_FLAGS) {
|
|
mb_len = WideCharToMultiByte(CP_THREAD_ACP, flags = 0, env->pathname.specified, -1, nullptr, 0, nullptr, nullptr);
|
|
rc = mb_len ? MDBX_SUCCESS : (int)GetLastError();
|
|
}
|
|
if (unlikely(rc != MDBX_SUCCESS))
|
|
return LOG_IFERR(rc);
|
|
|
|
char *const mb_pathname = osal_malloc(mb_len);
|
|
if (!mb_pathname)
|
|
return LOG_IFERR(MDBX_ENOMEM);
|
|
if (mb_len != (size_t)WideCharToMultiByte(CP_THREAD_ACP, flags, env->pathname.specified, -1, mb_pathname,
|
|
(int)mb_len, nullptr, nullptr)) {
|
|
rc = (int)GetLastError();
|
|
osal_free(mb_pathname);
|
|
return LOG_IFERR(rc);
|
|
}
|
|
if (env->pathname_char ||
|
|
InterlockedCompareExchangePointer((PVOID volatile *)&env->pathname_char, mb_pathname, nullptr))
|
|
osal_free(mb_pathname);
|
|
}
|
|
*arg = env->pathname_char;
|
|
#else
|
|
*arg = env->pathname.specified;
|
|
#endif /* Windows */
|
|
return MDBX_SUCCESS;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------------
|
|
* Legacy API */
|
|
|
|
#ifndef LIBMDBX_NO_EXPORTS_LEGACY_API
|
|
|
|
LIBMDBX_API int mdbx_txn_begin(MDBX_env *env, MDBX_txn *parent, MDBX_txn_flags_t flags, MDBX_txn **ret) {
|
|
return __inline_mdbx_txn_begin(env, parent, flags, ret);
|
|
}
|
|
|
|
LIBMDBX_API int mdbx_txn_commit(MDBX_txn *txn) { return __inline_mdbx_txn_commit(txn); }
|
|
|
|
LIBMDBX_API __cold int mdbx_env_stat(const MDBX_env *env, MDBX_stat *stat, size_t bytes) {
|
|
return __inline_mdbx_env_stat(env, stat, bytes);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_info(const MDBX_env *env, MDBX_envinfo *info, size_t bytes) {
|
|
return __inline_mdbx_env_info(env, info, bytes);
|
|
}
|
|
|
|
LIBMDBX_API int mdbx_dbi_flags(const MDBX_txn *txn, MDBX_dbi dbi, unsigned *flags) {
|
|
return __inline_mdbx_dbi_flags(txn, dbi, flags);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_sync(MDBX_env *env) { return __inline_mdbx_env_sync(env); }
|
|
|
|
LIBMDBX_API __cold int mdbx_env_sync_poll(MDBX_env *env) { return __inline_mdbx_env_sync_poll(env); }
|
|
|
|
LIBMDBX_API __cold int mdbx_env_close(MDBX_env *env) { return __inline_mdbx_env_close(env); }
|
|
|
|
LIBMDBX_API __cold int mdbx_env_set_mapsize(MDBX_env *env, size_t size) {
|
|
return __inline_mdbx_env_set_mapsize(env, size);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_set_maxdbs(MDBX_env *env, MDBX_dbi dbs) {
|
|
return __inline_mdbx_env_set_maxdbs(env, dbs);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_get_maxdbs(const MDBX_env *env, MDBX_dbi *dbs) {
|
|
return __inline_mdbx_env_get_maxdbs(env, dbs);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_set_maxreaders(MDBX_env *env, unsigned readers) {
|
|
return __inline_mdbx_env_set_maxreaders(env, readers);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_get_maxreaders(const MDBX_env *env, unsigned *readers) {
|
|
return __inline_mdbx_env_get_maxreaders(env, readers);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_set_syncbytes(MDBX_env *env, size_t threshold) {
|
|
return __inline_mdbx_env_set_syncbytes(env, threshold);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_get_syncbytes(const MDBX_env *env, size_t *threshold) {
|
|
return __inline_mdbx_env_get_syncbytes(env, threshold);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_set_syncperiod(MDBX_env *env, unsigned seconds_16dot16) {
|
|
return __inline_mdbx_env_set_syncperiod(env, seconds_16dot16);
|
|
}
|
|
|
|
LIBMDBX_API __cold int mdbx_env_get_syncperiod(const MDBX_env *env, unsigned *seconds_16dot16) {
|
|
return __inline_mdbx_env_get_syncperiod(env, seconds_16dot16);
|
|
}
|
|
|
|
LIBMDBX_API __cold uint64_t mdbx_key_from_int64(const int64_t i64) { return __inline_mdbx_key_from_int64(i64); }
|
|
|
|
LIBMDBX_API __cold uint32_t mdbx_key_from_int32(const int32_t i32) { return __inline_mdbx_key_from_int32(i32); }
|
|
|
|
LIBMDBX_API __cold intptr_t mdbx_limits_pgsize_min(void) { return __inline_mdbx_limits_pgsize_min(); }
|
|
|
|
LIBMDBX_API __cold intptr_t mdbx_limits_pgsize_max(void) { return __inline_mdbx_limits_pgsize_max(); }
|
|
|
|
#endif /* LIBMDBX_NO_EXPORTS_LEGACY_API */
|