tdb/common/tdb_private.h

ソースコードを見る。

データ構造
struct	list_struct
struct	tdb_header
struct	tdb_lock_type
struct	tdb_traverse_lock
struct	tdb_methods
struct	tdb_context
型定義
typedef u32	tdb_len_t
typedef u32	tdb_off_t
関数
int	tdb_munmap (struct tdb_context *tdb)
void	tdb_mmap (struct tdb_context *tdb)
int	tdb_lock (struct tdb_context *tdb, int list, int ltype)
int	tdb_unlock (struct tdb_context *tdb, int list, int ltype)
int	tdb_brlock (struct tdb_context *tdb, tdb_off_t offset, int rw_type, int lck_type, int probe, size_t len)
int	tdb_brlock_upgrade (struct tdb_context *tdb, tdb_off_t offset, size_t len)
int	tdb_write_lock_record (struct tdb_context *tdb, tdb_off_t off)
int	tdb_write_unlock_record (struct tdb_context *tdb, tdb_off_t off)
int	tdb_ofs_read (struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
int	tdb_ofs_write (struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
void *	tdb_convert (void *buf, u32 size)
int	tdb_free (struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
tdb_off_t	tdb_allocate (struct tdb_context *tdb, tdb_len_t length, struct list_struct *rec)
int	tdb_lock_record (struct tdb_context *tdb, tdb_off_t off)
int	tdb_unlock_record (struct tdb_context *tdb, tdb_off_t off)
int	tdb_rec_read (struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
int	tdb_rec_write (struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
int	tdb_do_delete (struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
char *	tdb_alloc_read (struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
int	tdb_parse_data (struct tdb_context *tdb, TDB_DATA key, tdb_off_t offset, tdb_len_t len, int(*parser)(TDB_DATA key, TDB_DATA data, void *private_data), void *private_data)
tdb_off_t	tdb_find_lock_hash (struct tdb_context *tdb, TDB_DATA key, u32 hash, int locktype, struct list_struct *rec)
void	tdb_io_init (struct tdb_context *tdb)
int	tdb_expand (struct tdb_context *tdb, tdb_off_t size)
int	rec_free_read (struct tdb_context *tdb, tdb_off_t off, struct list_struct *rec)

---

型定義

typedef u32 tdb_len_t

tdb_private.h の 43 行で定義されています。

typedef u32 tdb_off_t

tdb_private.h の 44 行で定義されています。

---

関数

int tdb_munmap

(

struct tdb_context *

tdb

)

io.c の 186 行で定義されています。

参照先 tdb_context::flags・tdb_context::map_ptr・tdb_context::map_size・tdb.

参照元 tdb_close()・tdb_expand()・tdb_oob()・tdb_open_ex()・tdb_reopen()・tdb_transaction_recover().

{
        if (tdb->flags & TDB_INTERNAL)
                return 0;

#ifdef HAVE_MMAP
        if (tdb->map_ptr) {
                int ret = munmap(tdb->map_ptr, tdb->map_size);
                if (ret != 0)
                        return ret;
        }
#endif
        tdb->map_ptr = NULL;
        return 0;
}

void tdb_mmap

(

struct tdb_context *

tdb

)

io.c の 202 行で定義されています。

参照先 errno・tdb_context::fd・tdb_context::flags・tdb_context::map_ptr・tdb_context::map_size・tdb_context::read_only・strerror()・tdb・TDB_DEBUG_WARNING.

参照元 tdb_expand()・tdb_oob()・tdb_open_ex()・tdb_reopen()・tdb_transaction_recover().

{
        if (tdb->flags & TDB_INTERNAL)
                return;

#ifdef HAVE_MMAP
        if (!(tdb->flags & TDB_NOMMAP)) {
                tdb->map_ptr = mmap(NULL, tdb->map_size, 
                                    PROT_READ|(tdb->read_only? 0:PROT_WRITE), 
                                    MAP_SHARED|MAP_FILE, tdb->fd, 0);

                /*
                 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
                 */

                if (tdb->map_ptr == MAP_FAILED) {
                        tdb->map_ptr = NULL;
                        TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n", 
                                 tdb->map_size, strerror(errno)));
                }
        } else {
                tdb->map_ptr = NULL;
        }
#else
        tdb->map_ptr = NULL;
#endif
}

int tdb_lock	(	struct tdb_context *	tdb,
		int	list,
		int	ltype
	)

lock.c の 120 行で定義されています。

参照先 tdb_lock_type::count・tdb_context::flags・tdb_context::global_lock・tdb_header::hash_size・tdb_context::header・tdb_lock_type::list・tdb_context::lockrecs・tdb_lock_type::ltype・tdb_context::num_lockrecs・tdb・TDB_DEBUG_ERROR・TDB_ERR_LOCK.

参照元 tdb_allocate()・tdb_append()・tdb_chainlock()・tdb_chainlock_read()・tdb_delete_hash()・tdb_dump_chain()・tdb_expand()・tdb_find_lock_hash()・tdb_free()・tdb_next_lock()・tdb_nextkey()・tdb_printfreelist()・tdb_purge_dead()・tdb_store()・tdb_validate_freelist().

{
        struct tdb_lock_type *new_lck;
        int i;

        /* a global lock allows us to avoid per chain locks */
        if (tdb->global_lock.count && 
            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
                return 0;
        }

        if (tdb->global_lock.count) {
                return TDB_ERRCODE(TDB_ERR_LOCK, -1);
        }

        if (list < -1 || list >= (int)tdb->header.hash_size) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid list %d for ltype=%d\n", 
                           list, ltype));
                return -1;
        }
        if (tdb->flags & TDB_NOLOCK)
                return 0;

        for (i=0; i<tdb->num_lockrecs; i++) {
                if (tdb->lockrecs[i].list == list) {
                        if (tdb->lockrecs[i].count == 0) {
                                /*
                                 * Can't happen, see tdb_unlock(). It should
                                 * be an assert.
                                 */
                                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock: "
                                         "lck->count == 0 for list %d", list));
                        }
                        /*
                         * Just increment the in-memory struct, posix locks
                         * don't stack.
                         */
                        tdb->lockrecs[i].count++;
                        return 0;
                }
        }

        new_lck = (struct tdb_lock_type *)realloc(
                tdb->lockrecs,
                sizeof(*tdb->lockrecs) * (tdb->num_lockrecs+1));
        if (new_lck == NULL) {
                errno = ENOMEM;
                return -1;
        }
        tdb->lockrecs = new_lck;

        /* Since fcntl locks don't nest, we do a lock for the first one,
           and simply bump the count for future ones */
        if (tdb->methods->tdb_brlock(tdb,FREELIST_TOP+4*list,ltype,F_SETLKW,
                                     0, 1)) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock failed on list %d "
                         "ltype=%d (%s)\n",  list, ltype, strerror(errno)));
                return -1;
        }

        tdb->num_locks++;

        tdb->lockrecs[tdb->num_lockrecs].list = list;
        tdb->lockrecs[tdb->num_lockrecs].count = 1;
        tdb->lockrecs[tdb->num_lockrecs].ltype = ltype;
        tdb->num_lockrecs += 1;

        return 0;
}

int tdb_unlock	(	struct tdb_context *	tdb,
		int	list,
		int	ltype
	)

lock.c の 193 行で定義されています。

参照先 tdb_lock_type::count・tdb_context::flags・tdb_context::global_lock・tdb_header::hash_size・tdb_context::header・tdb_lock_type::list・tdb_context::lockrecs・tdb_lock_type::ltype・tdb_context::num_lockrecs・tdb・TDB_DEBUG_ERROR・TDB_ERR_LOCK.

参照元 tdb_allocate()・tdb_append()・tdb_chainunlock()・tdb_chainunlock_read()・tdb_delete_hash()・tdb_dump_chain()・tdb_exists_hash()・tdb_expand()・tdb_fetch()・tdb_find_lock_hash()・tdb_firstkey()・tdb_free()・tdb_next_lock()・tdb_nextkey()・tdb_parse_record()・tdb_printfreelist()・tdb_purge_dead()・tdb_store()・tdb_traverse_internal()・tdb_validate_freelist().

{
        int ret = -1;
        int i;
        struct tdb_lock_type *lck = NULL;

        /* a global lock allows us to avoid per chain locks */
        if (tdb->global_lock.count && 
            (ltype == tdb->global_lock.ltype || ltype == F_RDLCK)) {
                return 0;
        }

        if (tdb->global_lock.count) {
                return TDB_ERRCODE(TDB_ERR_LOCK, -1);
        }

        if (tdb->flags & TDB_NOLOCK)
                return 0;

        /* Sanity checks */
        if (list < -1 || list >= (int)tdb->header.hash_size) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
                return ret;
        }

        for (i=0; i<tdb->num_lockrecs; i++) {
                if (tdb->lockrecs[i].list == list) {
                        lck = &tdb->lockrecs[i];
                        break;
                }
        }

        if ((lck == NULL) || (lck->count == 0)) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: count is 0\n"));
                return -1;
        }

        if (lck->count > 1) {
                lck->count--;
                return 0;
        }

        /*
         * This lock has count==1 left, so we need to unlock it in the
         * kernel. We don't bother with decrementing the in-memory array
         * element, we're about to overwrite it with the last array element
         * anyway.
         */

        ret = tdb->methods->tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK,
                                       F_SETLKW, 0, 1);
        tdb->num_locks--;

        /*
         * Shrink the array by overwriting the element just unlocked with the
         * last array element.
         */

        if (tdb->num_lockrecs > 1) {
                *lck = tdb->lockrecs[tdb->num_lockrecs-1];
        }
        tdb->num_lockrecs -= 1;

        /*
         * We don't bother with realloc when the array shrinks, but if we have
         * a completely idle tdb we should get rid of the locked array.
         */

        if (tdb->num_lockrecs == 0) {
                SAFE_FREE(tdb->lockrecs);
        }

        if (ret)
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: An error occurred unlocking!\n")); 
        return ret;
}

int tdb_brlock	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		int	rw_type,
		int	lck_type,
		int	probe,
		size_t	len
	)

lock.c の 44 行で定義されています。

参照先 tdb_context::ecode・errno・tdb_context::fd・tdb_context::flags・tdb_context::interrupt_sig_ptr・tdb_context::read_only・tdb・TDB_DEBUG_TRACE・TDB_ERR_LOCK・TDB_ERR_RDONLY・tdb_context::traverse_read.

参照元 tdb_brlock_upgrade()・tdb_increment_seqnum()・tdb_transaction_cancel()・tdb_transaction_commit()・tdb_transaction_start().

{
        struct flock fl;
        int ret;

        if (tdb->flags & TDB_NOLOCK) {
                return 0;
        }

        if ((rw_type == F_WRLCK) && (tdb->read_only || tdb->traverse_read)) {
                tdb->ecode = TDB_ERR_RDONLY;
                return -1;
        }

        fl.l_type = rw_type;
        fl.l_whence = SEEK_SET;
        fl.l_start = offset;
        fl.l_len = len;
        fl.l_pid = 0;

        do {
                ret = fcntl(tdb->fd,lck_type,&fl);

                /* Check for a sigalarm break. */
                if (ret == -1 && errno == EINTR &&
                                tdb->interrupt_sig_ptr &&
                                *tdb->interrupt_sig_ptr) {
                        break;
                }
        } while (ret == -1 && errno == EINTR);

        if (ret == -1) {
                /* Generic lock error. errno set by fcntl.
                 * EAGAIN is an expected return from non-blocking
                 * locks. */
                if (!probe && lck_type != F_SETLK) {
                        /* Ensure error code is set for log fun to examine. */
                        tdb->ecode = TDB_ERR_LOCK;
                        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n", 
                                 tdb->fd, offset, rw_type, lck_type, (int)len));
                }
                return TDB_ERRCODE(TDB_ERR_LOCK, -1);
        }
        return 0;
}

int tdb_brlock_upgrade	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		size_t	len
	)

lock.c の 98 行で定義されています。

参照先 errno・tdb・tdb_brlock()・TDB_DEBUG_TRACE.

参照元 tdb_transaction_commit().

{
        int count = 1000;
        while (count--) {
                struct timeval tv;
                if (tdb_brlock(tdb, offset, F_WRLCK, F_SETLKW, 1, len) == 0) {
                        return 0;
                }
                if (errno != EDEADLK) {
                        break;
                }
                /* sleep for as short a time as we can - more portable than usleep() */
                tv.tv_sec = 0;
                tv.tv_usec = 1;
                select(0, NULL, NULL, NULL, &tv);
        }
        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock_upgrade failed at offset %d\n", offset));
        return -1;
}

int tdb_write_lock_record	(	struct tdb_context *	tdb,
		tdb_off_t	off
	)

lock.c の 394 行で定義されています。

参照先 tdb_context::methods・tdb_traverse_lock::next・tdb_traverse_lock::off・tdb・tdb_methods::tdb_brlock・tdb_context::travlocks.

参照元 tdb_do_delete().

{
        struct tdb_traverse_lock *i;
        for (i = &tdb->travlocks; i; i = i->next)
                if (i->off == off)
                        return -1;
        return tdb->methods->tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1, 1);
}

int tdb_write_unlock_record	(	struct tdb_context *	tdb,
		tdb_off_t	off
	)

lock.c の 407 行で定義されています。

参照先 tdb_context::methods・tdb・tdb_methods::tdb_brlock.

参照元 tdb_do_delete().

{
        return tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0, 1);
}

int tdb_ofs_read	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		tdb_off_t *	d
	)

io.c の 364 行で定義されています。

参照先 tdb_context::methods・tdb・tdb_methods::tdb_read.

参照元 remove_from_freelist()・tdb_allocate()・tdb_count_dead()・tdb_do_delete()・tdb_dump_chain()・tdb_dump_record()・tdb_find()・tdb_find_dead()・tdb_free()・tdb_get_seqnum()・tdb_increment_seqnum()・tdb_next_lock()・tdb_printfreelist()・tdb_purge_dead()・tdb_recovery_allocate()・tdb_store()・tdb_transaction_recover()・tdb_validate_freelist().

{
        return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
}

int tdb_ofs_write	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		tdb_off_t *	d
	)

io.c の 369 行で定義されています。

参照先 tdb_context::methods・tdb・tdb_methods::tdb_write.

参照元 remove_from_freelist()・tdb_allocate_ofs()・tdb_do_delete()・tdb_free()・tdb_increment_seqnum()・tdb_store()・tdb_transaction_recover()・update_tailer().

{
        tdb_off_t off = *d;
        return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
}

void* tdb_convert	(	void *	buf,
		u32	size
	)

io.c の 122 行で定義されています。

参照元 tdb_open_ex()・tdb_read()・tdb_transaction_recover()・transaction_read()・transaction_setup_recovery().

{
        u32 i, *p = (u32 *)buf;
        for (i = 0; i < size / 4; i++)
                p[i] = TDB_BYTEREV(p[i]);
        return buf;
}

int tdb_free	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		struct list_struct *	rec
	)

freelist.c の 95 行で定義されています。

参照先 tdb_header::hash_size・tdb_context::header・tdb_context::map_size・tdb_context::methods・tdb_context::next・list_struct::rec_len・remove_from_freelist()・tdb・TDB_DEBUG_FATAL・tdb_lock()・tdb_ofs_read()・tdb_ofs_write()・tdb_methods::tdb_read・tdb_rec_write()・tdb_unlock()・update_tailer().

参照元 tdb_allocate_ofs()・tdb_do_delete()・tdb_expand()・tdb_recovery_allocate().

{
        tdb_off_t right, left;

        /* Allocation and tailer lock */
        if (tdb_lock(tdb, -1, F_WRLCK) != 0)
                return -1;

        /* set an initial tailer, so if we fail we don't leave a bogus record */
        if (update_tailer(tdb, offset, rec) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_tailer failed!\n"));
                goto fail;
        }

        /* Look right first (I'm an Australian, dammit) */
        right = offset + sizeof(*rec) + rec->rec_len;
        if (right + sizeof(*rec) <= tdb->map_size) {
                struct list_struct r;

                if (tdb->methods->tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: right read failed at %u\n", right));
                        goto left;
                }

                /* If it's free, expand to include it. */
                if (r.magic == TDB_FREE_MAGIC) {
                        if (remove_from_freelist(tdb, right, r.next) == -1) {
                                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: right free failed at %u\n", right));
                                goto left;
                        }
                        rec->rec_len += sizeof(r) + r.rec_len;
                }
        }

left:
        /* Look left */
        left = offset - sizeof(tdb_off_t);
        if (left > TDB_DATA_START(tdb->header.hash_size)) {
                struct list_struct l;
                tdb_off_t leftsize;
                
                /* Read in tailer and jump back to header */
                if (tdb_ofs_read(tdb, left, &leftsize) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: left offset read failed at %u\n", left));
                        goto update;
                }

                /* it could be uninitialised data */
                if (leftsize == 0 || leftsize == TDB_PAD_U32) {
                        goto update;
                }

                left = offset - leftsize;

                /* Now read in record */
                if (tdb->methods->tdb_read(tdb, left, &l, sizeof(l), DOCONV()) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: left read failed at %u (%u)\n", left, leftsize));
                        goto update;
                }

                /* If it's free, expand to include it. */
                if (l.magic == TDB_FREE_MAGIC) {
                        if (remove_from_freelist(tdb, left, l.next) == -1) {
                                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: left free failed at %u\n", left));
                                goto update;
                        } else {
                                offset = left;
                                rec->rec_len += leftsize;
                        }
                }
        }

update:
        if (update_tailer(tdb, offset, rec) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free: update_tailer failed at %u\n", offset));
                goto fail;
        }

        /* Now, prepend to free list */
        rec->magic = TDB_FREE_MAGIC;

        if (tdb_ofs_read(tdb, FREELIST_TOP, &rec->next) == -1 ||
            tdb_rec_write(tdb, offset, rec) == -1 ||
            tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_free record write failed at offset=%d\n", offset));
                goto fail;
        }

        /* And we're done. */
        tdb_unlock(tdb, -1, F_WRLCK);
        return 0;

 fail:
        tdb_unlock(tdb, -1, F_WRLCK);
        return -1;
}

tdb_off_t tdb_allocate	(	struct tdb_context *	tdb,
		tdb_len_t	length,
		struct list_struct *	rec
	)

freelist.c の 258 行で定義されています。

参照先 last_ptr・list_struct::next・rec_free_read()・list_struct::rec_len・tdb・tdb_allocate_ofs()・tdb_expand()・tdb_lock()・tdb_ofs_read()・tdb_unlock().

参照元 tdb_store().

{
        tdb_off_t rec_ptr, last_ptr, newrec_ptr;
        struct {
                tdb_off_t rec_ptr, last_ptr;
                tdb_len_t rec_len;
        } bestfit;

        if (tdb_lock(tdb, -1, F_WRLCK) == -1)
                return 0;

        /* Extra bytes required for tailer */
        length += sizeof(tdb_off_t);

 again:
        last_ptr = FREELIST_TOP;

        /* read in the freelist top */
        if (tdb_ofs_read(tdb, FREELIST_TOP, &rec_ptr) == -1)
                goto fail;

        bestfit.rec_ptr = 0;
        bestfit.last_ptr = 0;
        bestfit.rec_len = 0;

        /* 
           this is a best fit allocation strategy. Originally we used
           a first fit strategy, but it suffered from massive fragmentation
           issues when faced with a slowly increasing record size.
         */
        while (rec_ptr) {
                if (rec_free_read(tdb, rec_ptr, rec) == -1) {
                        goto fail;
                }

                if (rec->rec_len >= length) {
                        if (bestfit.rec_ptr == 0 ||
                            rec->rec_len < bestfit.rec_len) {
                                bestfit.rec_len = rec->rec_len;
                                bestfit.rec_ptr = rec_ptr;
                                bestfit.last_ptr = last_ptr;
                                /* consider a fit to be good enough if
                                   we aren't wasting more than half
                                   the space */
                                if (bestfit.rec_len < 2*length) {
                                        break;
                                }
                        }
                }

                /* move to the next record */
                last_ptr = rec_ptr;
                rec_ptr = rec->next;
        }

        if (bestfit.rec_ptr != 0) {
                if (rec_free_read(tdb, bestfit.rec_ptr, rec) == -1) {
                        goto fail;
                }

                newrec_ptr = tdb_allocate_ofs(tdb, length, bestfit.rec_ptr, rec, bestfit.last_ptr);
                tdb_unlock(tdb, -1, F_WRLCK);
                return newrec_ptr;
        }

        /* we didn't find enough space. See if we can expand the
           database and if we can then try again */
        if (tdb_expand(tdb, length + sizeof(*rec)) == 0)
                goto again;
 fail:
        tdb_unlock(tdb, -1, F_WRLCK);
        return 0;
}

int tdb_lock_record	(	struct tdb_context *	tdb,
		tdb_off_t	off
	)

lock.c の 384 行で定義されています。

参照先 tdb_context::methods・tdb・tdb_methods::tdb_brlock.

参照元 tdb_next_lock()・tdb_nextkey().

{
        return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0, 1) : 0;
}

int tdb_unlock_record	(	struct tdb_context *	tdb,
		tdb_off_t	off
	)

lock.c の 413 行で定義されています。

参照先 tdb_context::methods・tdb_traverse_lock::next・tdb_traverse_lock::off・tdb・tdb_methods::tdb_brlock・tdb_context::travlocks.

参照元 tdb_firstkey()・tdb_next_lock()・tdb_nextkey()・tdb_traverse_internal().

{
        struct tdb_traverse_lock *i;
        u32 count = 0;

        if (off == 0)
                return 0;
        for (i = &tdb->travlocks; i; i = i->next)
                if (i->off == off)
                        count++;
        return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0, 1) : 0);
}

int tdb_rec_read	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		struct list_struct *	rec
	)

io.c の 435 行で定義されています。

参照先 tdb_context::ecode・tdb_context::methods・tdb_context::next・tdb・TDB_DEBUG_FATAL・TDB_ERR_CORRUPT・tdb_methods::tdb_oob・tdb_methods::tdb_read.

参照元 tdb_count_dead()・tdb_do_delete()・tdb_find()・tdb_find_dead()・tdb_next_lock()・tdb_nextkey()・tdb_purge_dead().

{
        if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
                return -1;
        if (TDB_BAD_MAGIC(rec)) {
                /* Ensure ecode is set for log fn. */
                tdb->ecode = TDB_ERR_CORRUPT;
                TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
                return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
        }
        return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
}

int tdb_rec_write	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		struct list_struct *	rec
	)

io.c の 448 行で定義されています。

参照先 tdb_context::methods・tdb・tdb_methods::tdb_write.

参照元 tdb_allocate_ofs()・tdb_delete_hash()・tdb_do_delete()・tdb_free()・tdb_store()・tdb_update_hash().

{
        struct list_struct r = *rec;
        return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
}

int tdb_do_delete	(	struct tdb_context *	tdb,
		tdb_off_t	rec_ptr,
		struct list_struct *	rec
	)

tdb.c の 227 行で定義されています。

参照先 list_struct::full_hash・last_ptr・list_struct::magic・list_struct::next・tdb_context::read_only・tdb・tdb_free()・tdb_ofs_read()・tdb_ofs_write()・tdb_rec_read()・tdb_rec_write()・tdb_write_lock_record()・tdb_write_unlock_record()・tdb_context::traverse_read.

参照元 tdb_delete_hash()・tdb_next_lock()・tdb_purge_dead().

{
        tdb_off_t last_ptr, i;
        struct list_struct lastrec;

        if (tdb->read_only || tdb->traverse_read) return -1;

        if (tdb_write_lock_record(tdb, rec_ptr) == -1) {
                /* Someone traversing here: mark it as dead */
                rec->magic = TDB_DEAD_MAGIC;
                return tdb_rec_write(tdb, rec_ptr, rec);
        }
        if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
                return -1;

        /* find previous record in hash chain */
        if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
                return -1;
        for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
                if (tdb_rec_read(tdb, i, &lastrec) == -1)
                        return -1;

        /* unlink it: next ptr is at start of record. */
        if (last_ptr == 0)
                last_ptr = TDB_HASH_TOP(rec->full_hash);
        if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
                return -1;

        /* recover the space */
        if (tdb_free(tdb, rec_ptr, rec) == -1)
                return -1;
        return 0;
}

char* tdb_alloc_read	(	struct tdb_context *	tdb,
		tdb_off_t	offset,
		tdb_len_t	len
	)

io.c の 377 行で定義されています。

参照先 buf・tdb_context::ecode・errno・tdb_context::methods・strerror()・tdb・TDB_DEBUG_ERROR・TDB_ERR_OOM・tdb_methods::tdb_read.

参照元 tdb_fetch()・tdb_firstkey()・tdb_nextkey()・tdb_parse_data()・tdb_traverse_internal().

{
        char *buf;

        /* some systems don't like zero length malloc */
        if (len == 0) {
                len = 1;
        }

        if (!(buf = (char *)malloc(len))) {
                /* Ensure ecode is set for log fn. */
                tdb->ecode = TDB_ERR_OOM;
                TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
                           len, strerror(errno)));
                return TDB_ERRCODE(TDB_ERR_OOM, buf);
        }
        if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
                SAFE_FREE(buf);
                return NULL;
        }
        return buf;
}

int tdb_parse_data	(	struct tdb_context *	tdb,
		TDB_DATA	key,
		tdb_off_t	offset,
		tdb_len_t	len,
		int(*)(TDB_DATA key, TDB_DATA data, void *private_data)	parser,
		void *	private_data
	)

io.c の 402 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・tdb_context::map_ptr・tdb_context::methods・result・tdb・tdb_alloc_read()・tdb_methods::tdb_oob・tdb_context::transaction.

参照元 tdb_find()・tdb_parse_record().

{
        TDB_DATA data;
        int result;

        data.dsize = len;

        if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
                /*
                 * Optimize by avoiding the malloc/memcpy/free, point the
                 * parser directly at the mmap area.
                 */
                if (tdb->methods->tdb_oob(tdb, offset+len, 0) != 0) {
                        return -1;
                }
                data.dptr = offset + (char *)tdb->map_ptr;
                return parser(key, data, private_data);
        }

        if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
                return -1;
        }

        result = parser(key, data, private_data);
        free(data.dptr);
        return result;
}

tdb_off_t tdb_find_lock_hash	(	struct tdb_context *	tdb,
		TDB_DATA	key,
		u32	hash,
		int	locktype,
		struct list_struct *	rec
	)

tdb.c の 93 行で定義されています。

参照先 tdb・tdb_find()・tdb_lock()・tdb_unlock().

参照元 tdb_delete_hash()・tdb_exists_hash()・tdb_fetch()・tdb_nextkey()・tdb_parse_record().

{
        u32 rec_ptr;

        if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
                return 0;
        if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
                tdb_unlock(tdb, BUCKET(hash), locktype);
        return rec_ptr;
}

void tdb_io_init

(

struct tdb_context *

tdb

)

io.c の 466 行で定義されています。

参照先 io_methods・tdb_context::methods・tdb.

参照元 tdb_open_ex().

{
        tdb->methods = &io_methods;
}

int tdb_expand	(	struct tdb_context *	tdb,
		tdb_off_t	size
	)

io.c の 294 行で定義されています。

参照先 tdb_context::flags・tdb_context::map_size・tdb_context::methods・tdb_context::page_size・tdb・TDB_DEBUG_ERROR・tdb_free()・tdb_lock()・tdb_mmap()・tdb_munmap()・tdb_methods::tdb_oob・tdb_unlock().

参照元 tdb_allocate().

{
        struct list_struct rec;
        tdb_off_t offset;

        if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
                return -1;
        }

        /* must know about any previous expansions by another process */
        tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);

        /* always make room for at least 10 more records, and round
           the database up to a multiple of the page size */
        size = TDB_ALIGN(tdb->map_size + size*10, tdb->page_size) - tdb->map_size;

        if (!(tdb->flags & TDB_INTERNAL))
                tdb_munmap(tdb);

        /*
         * We must ensure the file is unmapped before doing this
         * to ensure consistency with systems like OpenBSD where
         * writes and mmaps are not consistent.
         */

        /* expand the file itself */
        if (!(tdb->flags & TDB_INTERNAL)) {
                if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
                        goto fail;
        }

        tdb->map_size += size;

        if (tdb->flags & TDB_INTERNAL) {
                char *new_map_ptr = (char *)realloc(tdb->map_ptr,
                                                    tdb->map_size);
                if (!new_map_ptr) {
                        tdb->map_size -= size;
                        goto fail;
                }
                tdb->map_ptr = new_map_ptr;
        } else {
                /*
                 * We must ensure the file is remapped before adding the space
                 * to ensure consistency with systems like OpenBSD where
                 * writes and mmaps are not consistent.
                 */

                /* We're ok if the mmap fails as we'll fallback to read/write */
                tdb_mmap(tdb);
        }

        /* form a new freelist record */
        memset(&rec,'\0',sizeof(rec));
        rec.rec_len = size - sizeof(rec);

        /* link it into the free list */
        offset = tdb->map_size - size;
        if (tdb_free(tdb, offset, &rec) == -1)
                goto fail;

        tdb_unlock(tdb, -1, F_WRLCK);
        return 0;
 fail:
        tdb_unlock(tdb, -1, F_WRLCK);
        return -1;
}

int rec_free_read	(	struct tdb_context *	tdb,
		tdb_off_t	off,
		struct list_struct *	rec
	)

freelist.c の 32 行で定義されています。

参照先 tdb_context::ecode・tdb_context::methods・tdb_context::next・tdb・TDB_DEBUG_WARNING・TDB_ERR_CORRUPT・tdb_methods::tdb_oob・tdb_methods::tdb_read.

参照元 tdb_allocate()・tdb_validate_freelist().

{
        if (tdb->methods->tdb_read(tdb, off, rec, sizeof(*rec),DOCONV()) == -1)
                return -1;

        if (rec->magic == TDB_MAGIC) {
                /* this happens when a app is showdown while deleting a record - we should
                   not completely fail when this happens */
                TDB_LOG((tdb, TDB_DEBUG_WARNING, "rec_free_read non-free magic 0x%x at offset=%d - fixing\n", 
                         rec->magic, off));
                rec->magic = TDB_FREE_MAGIC;
                if (tdb->methods->tdb_write(tdb, off, rec, sizeof(*rec)) == -1)
                        return -1;
        }

        if (rec->magic != TDB_FREE_MAGIC) {
                /* Ensure ecode is set for log fn. */
                tdb->ecode = TDB_ERR_CORRUPT;
                TDB_LOG((tdb, TDB_DEBUG_WARNING, "rec_free_read bad magic 0x%x at offset=%d\n", 
                           rec->magic, off));
                return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
        }
        if (tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
                return -1;
        return 0;
}

---