tdb/common/io.c

ソースコードを見る。

関数
static int	tdb_oob (struct tdb_context *tdb, tdb_off_t len, int probe)
static int	tdb_write (struct tdb_context *tdb, tdb_off_t off, const void *buf, tdb_len_t len)
void *	tdb_convert (void *buf, u32 size)
static int	tdb_read (struct tdb_context *tdb, tdb_off_t off, void *buf, tdb_len_t len, int cv)
static void	tdb_next_hash_chain (struct tdb_context *tdb, u32 *chain)
int	tdb_munmap (struct tdb_context *tdb)
void	tdb_mmap (struct tdb_context *tdb)
static int	tdb_expand_file (struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
int	tdb_expand (struct tdb_context *tdb, tdb_off_t size)
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)
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)
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)
void	tdb_io_init (struct tdb_context *tdb)
変数
static struct tdb_methods	io_methods

---

関数

static int tdb_oob	(	struct tdb_context *	tdb,
		tdb_off_t	len,
		int	probe
	)			[static]

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

参照先 tdb_context::ecode・tdb_context::fd・tdb_context::flags・tdb_context::map_size・tdb・TDB_DEBUG_FATAL・TDB_ERR_IO・tdb_mmap()・tdb_munmap().

{
        struct stat st;
        if (len <= tdb->map_size)
                return 0;
        if (tdb->flags & TDB_INTERNAL) {
                if (!probe) {
                        /* Ensure ecode is set for log fn. */
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond internal malloc size %d\n",
                                 (int)len, (int)tdb->map_size));
                }
                return TDB_ERRCODE(TDB_ERR_IO, -1);
        }

        if (fstat(tdb->fd, &st) == -1) {
                return TDB_ERRCODE(TDB_ERR_IO, -1);
        }

        if (st.st_size < (size_t)len) {
                if (!probe) {
                        /* Ensure ecode is set for log fn. */
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond eof at %d\n",
                                 (int)len, (int)st.st_size));
                }
                return TDB_ERRCODE(TDB_ERR_IO, -1);
        }

        /* Unmap, update size, remap */
        if (tdb_munmap(tdb) == -1)
                return TDB_ERRCODE(TDB_ERR_IO, -1);
        tdb->map_size = st.st_size;
        tdb_mmap(tdb);
        return 0;
}

static int tdb_write	(	struct tdb_context *	tdb,
		tdb_off_t	off,
		const void *	buf,
		tdb_len_t	len
	)			[static]

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

参照先 tdb_context::ecode・errno・tdb_context::fd・tdb_context::map_ptr・tdb_context::methods・tdb_context::read_only・strerror()・tdb・TDB_DEBUG_FATAL・TDB_ERR_IO・TDB_ERR_RDONLY・tdb_methods::tdb_oob・tdb_context::traverse_read.

{
        if (len == 0) {
                return 0;
        }

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

        if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
                return -1;

        if (tdb->map_ptr) {
                memcpy(off + (char *)tdb->map_ptr, buf, len);
        } else {
                ssize_t written = pwrite(tdb->fd, buf, len, off);
                if ((written != (ssize_t)len) && (written != -1)) {
                        /* try once more */
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
                                 "%d of %d bytes at %d, trying once more\n",
                                 (uint32_t)written, len, off));
                        errno = ENOSPC;
                        written = pwrite(tdb->fd, (void *)((char *)buf+written),
                                         len-written,
                                         off+written);
                }
                if (written == -1) {
                        /* Ensure ecode is set for log fn. */
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
                                 "len=%d (%s)\n", off, len, strerror(errno)));
                        return TDB_ERRCODE(TDB_ERR_IO, -1);
                } else if (written != (ssize_t)len) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
                                 "write %d bytes at %d in two attempts\n",
                                 len, off));
                        errno = ENOSPC;
                        return TDB_ERRCODE(TDB_ERR_IO, -1);
                }
        }
        return 0;
}

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;
}

static int tdb_read	(	struct tdb_context *	tdb,
		tdb_off_t	off,
		void *	buf,
		tdb_len_t	len,
		int	cv
	)			[static]

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

参照先 tdb_context::ecode・errno・tdb_context::fd・tdb_context::map_ptr・tdb_context::map_size・tdb_context::methods・strerror()・tdb・tdb_convert()・TDB_DEBUG_FATAL・TDB_ERR_IO・tdb_methods::tdb_oob.

{
        if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0) {
                return -1;
        }

        if (tdb->map_ptr) {
                memcpy(buf, off + (char *)tdb->map_ptr, len);
        } else {
                ssize_t ret = pread(tdb->fd, buf, len, off);
                if (ret != (ssize_t)len) {
                        /* Ensure ecode is set for log fn. */
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d "
                                 "len=%d ret=%d (%s) map_size=%d\n",
                                 (int)off, (int)len, (int)ret, strerror(errno),
                                 (int)tdb->map_size));
                        return TDB_ERRCODE(TDB_ERR_IO, -1);
                }
        }
        if (cv) {
                tdb_convert(buf, len);
        }
        return 0;
}

static void tdb_next_hash_chain	(	struct tdb_context *	tdb,
		u32 *	chain
	)			[static]

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

参照先 tdb_header::hash_size・tdb_context::header・tdb_context::map_ptr・tdb.

{
        u32 h = *chain;
        if (tdb->map_ptr) {
                for (;h < tdb->header.hash_size;h++) {
                        if (0 != *(u32 *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
                                break;
                        }
                }
        } else {
                u32 off=0;
                for (;h < tdb->header.hash_size;h++) {
                        if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
                                break;
                        }
                }
        }
        (*chain) = h;
}

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
}

static int tdb_expand_file	(	struct tdb_context *	tdb,
		tdb_off_t	size,
		tdb_off_t	addition
	)			[static]

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

参照先 buf・tdb_context::ecode・errno・tdb_context::fd・tdb_context::read_only・strerror()・tdb・TDB_DEBUG_FATAL・TDB_DEBUG_WARNING・TDB_ERR_RDONLY・tdb_context::traverse_read.

{
        char buf[1024];

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

        if (ftruncate(tdb->fd, size+addition) == -1) {
                char b = 0;
                ssize_t written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
                if (written == 0) {
                        /* try once more, potentially revealing errno */
                        written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
                }
                if (written == 0) {
                        /* again - give up, guessing errno */
                        errno = ENOSPC;
                }
                if (written != 1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n", 
                                 size+addition, strerror(errno)));
                        return -1;
                }
        }

        /* now fill the file with something. This ensures that the
           file isn't sparse, which would be very bad if we ran out of
           disk. This must be done with write, not via mmap */
        memset(buf, TDB_PAD_BYTE, sizeof(buf));
        while (addition) {
                size_t n = addition>sizeof(buf)?sizeof(buf):addition;
                ssize_t written = pwrite(tdb->fd, buf, n, size);
                if (written == 0) {
                        /* prevent infinite loops: try _once_ more */
                        written = pwrite(tdb->fd, buf, n, size);
                }
                if (written == 0) {
                        /* give up, trying to provide a useful errno */
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write "
                                "returned 0 twice: giving up!\n"));
                        errno = ENOSPC;
                        return -1;
                } else if (written == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of "
                                "%d bytes failed (%s)\n", (uint32_t)n, strerror(errno)));
                        return -1;
                } else if (written != n) {
                        TDB_LOG((tdb, TDB_DEBUG_WARNING, "expand_file: wrote "
                                "only %d of %d bytes - retrying\n",
                                (uint32_t)written, (uint32_t)n));
                }
                addition -= written;
                size += written;
        }
        return 0;
}

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 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));
}

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;
}

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));
}

void tdb_io_init

(

struct tdb_context *

tdb

)

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

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

参照元 tdb_open_ex().

{
        tdb->methods = &io_methods;
}

---

変数

struct tdb_methods io_methods [static]

初期値:

 {
        tdb_read,
        tdb_write,
        tdb_next_hash_chain,
        tdb_oob,
        tdb_expand_file,
        tdb_brlock
}

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

参照元 tdb_io_init().

---