if (tdb->flags & TDB_NOMMAP)
return;
- tdb->file->map_ptr = mmap(NULL, tdb->file->map_size, tdb->mmap_flags,
- MAP_SHARED, tdb->file->fd, 0);
+ /* size_t can be smaller than off_t. */
+ if ((size_t)tdb->file->map_size == tdb->file->map_size) {
+ tdb->file->map_ptr = mmap(NULL, tdb->file->map_size,
+ tdb->mmap_flags,
+ MAP_SHARED, tdb->file->fd, 0);
+ } else
+ tdb->file->map_ptr = MAP_FAILED;
/*
* NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
/* check for an out of bounds access - if it is out of bounds then
see if the database has been expanded by someone else and expand
if necessary
- note that "len" is the minimum length needed for the db
+ note that "len" is the minimum length needed for the db.
+
+ If probe is true, len being too large isn't a failure.
*/
static enum TDB_ERROR tdb_oob(struct tdb_context *tdb, tdb_off_t len,
bool probe)
|| tdb_has_expansion_lock(tdb));
if (len <= tdb->file->map_size)
- return 0;
+ return TDB_SUCCESS;
if (tdb->flags & TDB_INTERNAL) {
- if (!probe) {
- tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb_oob len %lld beyond internal"
- " malloc size %lld",
- (long long)len,
- (long long)tdb->file->map_size);
- }
+ if (probe)
+ return TDB_SUCCESS;
+
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob len %lld beyond internal"
+ " malloc size %lld",
+ (long long)len,
+ (long long)tdb->file->map_size);
return TDB_ERR_IO;
}
tdb_unlock_expand(tdb, F_RDLCK);
if (st.st_size < (size_t)len) {
- if (!probe) {
- tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
- "tdb_oob len %zu beyond eof at %zu",
- (size_t)len, st.st_size);
- }
+ if (probe)
+ return TDB_SUCCESS;
+
+ tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
+ "tdb_oob len %zu beyond eof at %zu",
+ (size_t)len, st.st_size);
return TDB_ERR_IO;
}
/* Endian conversion: we only ever deal with 8 byte quantities */
void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size)
{
+ assert(size % 8 == 0);
if (unlikely((tdb->flags & TDB_CONVERT)) && buf) {
uint64_t i, *p = (uint64_t *)buf;
for (i = 0; i < size / 8; i++)
"Write to read-only database");
}
- ecode = tdb->methods->oob(tdb, off + len, 0);
+ ecode = tdb->methods->oob(tdb, off + len, false);
if (ecode != TDB_SUCCESS) {
return ecode;
}
{
enum TDB_ERROR ecode;
- ecode = tdb->methods->oob(tdb, off + len, 0);
+ ecode = tdb->methods->oob(tdb, off + len, false);
if (ecode != TDB_SUCCESS) {
return ecode;
}
static void *_tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset,
tdb_len_t len, unsigned int prefix)
{
- void *buf;
+ unsigned char *buf;
enum TDB_ERROR ecode;
/* some systems don't like zero length malloc */
const void *tdb_access_read(struct tdb_context *tdb,
tdb_off_t off, tdb_len_t len, bool convert)
{
- const void *ret = NULL;
+ void *ret = NULL;
if (likely(!(tdb->flags & TDB_CONVERT))) {
ret = tdb->methods->direct(tdb, off, len, false);
if (unlikely(!tdb->file->map_ptr))
return NULL;
- ecode = tdb_oob(tdb, off + len, true);
+ ecode = tdb_oob(tdb, off + len, false);
if (unlikely(ecode != TDB_SUCCESS))
return TDB_ERR_PTR(ecode);
return (char *)tdb->file->map_ptr + off;
}
-void add_stat_(struct tdb_context *tdb, uint64_t *s, size_t val)
+void tdb_inc_seqnum(struct tdb_context *tdb)
{
- if ((uintptr_t)s < (uintptr_t)tdb->stats + tdb->stats->size)
- *s += val;
+ tdb_off_t seq;
+
+ if (likely(!(tdb->flags & TDB_CONVERT))) {
+ int64_t *direct;
+
+ direct = tdb->methods->direct(tdb,
+ offsetof(struct tdb_header,
+ seqnum),
+ sizeof(*direct), true);
+ if (likely(direct)) {
+ /* Don't let it go negative, even briefly */
+ if (unlikely((*direct) + 1) < 0)
+ *direct = 0;
+ (*direct)++;
+ return;
+ }
+ }
+
+ seq = tdb_read_off(tdb, offsetof(struct tdb_header, seqnum));
+ if (!TDB_OFF_IS_ERR(seq)) {
+ seq++;
+ if (unlikely((int64_t)seq < 0))
+ seq = 0;
+ tdb_write_off(tdb, offsetof(struct tdb_header, seqnum), seq);
+ }
}
static const struct tdb_methods io_methods = {