tdb/include/tdb.h

ソースコードを見る。

データ構造
struct	TDB_DATA
struct	tdb_logging_context
型定義
typedef tdb_context	TDB_CONTEXT
typedef int(*)	tdb_traverse_func (struct tdb_context *, TDB_DATA, TDB_DATA, void *)
typedef void(*)	tdb_log_func (struct tdb_context *, enum tdb_debug_level, const char *,...) PRINTF_ATTRIBUTE(3
typedef void(*) typedef unsigned int(*)	tdb_hash_func (TDB_DATA *key)
列挙型
enum	TDB_ERROR {   TDB_SUCCESS = 0, TDB_ERR_CORRUPT, TDB_ERR_IO,   TDB_ERR_LOCK, TDB_ERR_OOM, TDB_ERR_EXISTS,   TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT, TDB_ERR_NOEXIST,   TDB_ERR_EINVAL, TDB_ERR_RDONLY }
enum	tdb_debug_level {   TDB_DEBUG_FATAL = 0, TDB_DEBUG_ERROR, TDB_DEBUG_WARNING,   TDB_DEBUG_TRACE }
関数
tdb_context *	tdb_open (const char *name, int hash_size, int tdb_flags, int open_flags, mode_t mode)
tdb_context *	tdb_open_ex (const char *name, int hash_size, int tdb_flags, int open_flags, mode_t mode, const struct tdb_logging_context *log_ctx, tdb_hash_func hash_fn)
void	tdb_set_max_dead (struct tdb_context *tdb, int max_dead)
int	tdb_reopen (struct tdb_context *tdb)
int	tdb_reopen_all (int parent_longlived)
void	tdb_set_logging_function (struct tdb_context *tdb, const struct tdb_logging_context *log_ctx)
enum TDB_ERROR	tdb_error (struct tdb_context *tdb)
const char *	tdb_errorstr (struct tdb_context *tdb)
TDB_DATA	tdb_fetch (struct tdb_context *tdb, TDB_DATA key)
int	tdb_parse_record (struct tdb_context *tdb, TDB_DATA key, int(*parser)(TDB_DATA key, TDB_DATA data, void *private_data), void *private_data)
int	tdb_delete (struct tdb_context *tdb, TDB_DATA key)
int	tdb_store (struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
int	tdb_append (struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
int	tdb_close (struct tdb_context *tdb)
	Close a database.
TDB_DATA	tdb_firstkey (struct tdb_context *tdb)
TDB_DATA	tdb_nextkey (struct tdb_context *tdb, TDB_DATA key)
int	tdb_traverse (struct tdb_context *tdb, tdb_traverse_func fn, void *)
int	tdb_traverse_read (struct tdb_context *tdb, tdb_traverse_func fn, void *)
int	tdb_exists (struct tdb_context *tdb, TDB_DATA key)
int	tdb_lockall (struct tdb_context *tdb)
int	tdb_unlockall (struct tdb_context *tdb)
int	tdb_lockall_read (struct tdb_context *tdb)
int	tdb_unlockall_read (struct tdb_context *tdb)
const char *	tdb_name (struct tdb_context *tdb)
int	tdb_fd (struct tdb_context *tdb)
tdb_log_func	tdb_log_fn (struct tdb_context *tdb)
void *	tdb_get_logging_private (struct tdb_context *tdb)
int	tdb_transaction_start (struct tdb_context *tdb)
int	tdb_transaction_commit (struct tdb_context *tdb)
int	tdb_transaction_cancel (struct tdb_context *tdb)
int	tdb_transaction_recover (struct tdb_context *tdb)
int	tdb_get_seqnum (struct tdb_context *tdb)
int	tdb_hash_size (struct tdb_context *tdb)
size_t	tdb_map_size (struct tdb_context *tdb)
int	tdb_get_flags (struct tdb_context *tdb)
int	tdb_chainlock (struct tdb_context *tdb, TDB_DATA key)
int	tdb_chainunlock (struct tdb_context *tdb, TDB_DATA key)
int	tdb_chainlock_read (struct tdb_context *tdb, TDB_DATA key)
int	tdb_chainunlock_read (struct tdb_context *tdb, TDB_DATA key)
void	tdb_setalarm_sigptr (struct tdb_context *tdb, volatile sig_atomic_t *sigptr)
void	tdb_dump_all (struct tdb_context *tdb)
int	tdb_printfreelist (struct tdb_context *tdb)
int	tdb_validate_freelist (struct tdb_context *tdb, int *pnum_entries)
変数
TDB_DATA	tdb_null

---

型定義

typedef struct tdb_context TDB_CONTEXT

tdb.h の 80 行で定義されています。

typedef int(*) tdb_traverse_func(struct tdb_context *, TDB_DATA, TDB_DATA, void *)

tdb.h の 82 行で定義されています。

typedef void(*) tdb_log_func(struct tdb_context *, enum tdb_debug_level, const char *,...) PRINTF_ATTRIBUTE(3

tdb.h の 83 行で定義されています。

typedef void(*) typedef unsigned int(*) tdb_hash_func(TDB_DATA *key)

tdb.h の 84 行で定義されています。

---

列挙型

enum TDB_ERROR

列挙型の値:

TDB_SUCCESS
TDB_ERR_CORRUPT
TDB_ERR_IO
TDB_ERR_LOCK
TDB_ERR_OOM
TDB_ERR_EXISTS
TDB_ERR_NOLOCK
TDB_ERR_LOCK_TIMEOUT
TDB_ERR_NOEXIST
TDB_ERR_EINVAL
TDB_ERR_RDONLY

tdb.h の 54 行で定義されています。

               {TDB_SUCCESS=0, TDB_ERR_CORRUPT, TDB_ERR_IO, TDB_ERR_LOCK, 
                TDB_ERR_OOM, TDB_ERR_EXISTS, TDB_ERR_NOLOCK, TDB_ERR_LOCK_TIMEOUT,
                TDB_ERR_NOEXIST, TDB_ERR_EINVAL, TDB_ERR_RDONLY};

enum tdb_debug_level

列挙型の値:

TDB_DEBUG_FATAL
TDB_DEBUG_ERROR
TDB_DEBUG_WARNING
TDB_DEBUG_TRACE

tdb.h の 59 行で定義されています。

                     {TDB_DEBUG_FATAL = 0, TDB_DEBUG_ERROR, 
                      TDB_DEBUG_WARNING, TDB_DEBUG_TRACE};

---

関数

struct tdb_context* tdb_open	(	const char *	name,
		int	hash_size,
		int	tdb_flags,
		int	open_flags,
		mode_t	mode
	)

open.c の 133 行で定義されています。

参照先 tdb_open_ex().

参照元 backup_tdb()・create_tdb()・dump_tdb()・hash_a_service()・main()・move_rec()・open_tdb()・py_tdb_open()・smb_share_mode_db_open()・tdb_validate_freelist()・torture_mangle()・verify_tdb().

{
        return tdb_open_ex(name, hash_size, tdb_flags, open_flags, mode, NULL, NULL);
}

struct tdb_context* tdb_open_ex	(	const char *	name,
		int	hash_size,
		int	tdb_flags,
		int	open_flags,
		mode_t	mode,
		const struct tdb_logging_context *	log_ctx,
		tdb_hash_func	hash_fn
	)

open.c の 146 行で定義されています。

参照先 default_tdb_hash()・errno・tdb_logging_context::log_fn・null_log_fn()・strdup()・strerror()・tdb・tdb_already_open()・tdb_convert()・TDB_DEBUG_ERROR・TDB_DEBUG_FATAL・TDB_DEBUG_WARNING・tdb_io_init()・tdb_mmap()・tdb_munmap()・tdb_new_database()・tdb_transaction_recover()・tdbs.

参照元 main()・mangle_hash_init()・reset_stat_cache()・tdb_open()・tdb_open_log().

{
        struct tdb_context *tdb;
        struct stat st;
        int rev = 0, locked = 0;
        unsigned char *vp;
        u32 vertest;

        if (!(tdb = (struct tdb_context *)calloc(1, sizeof *tdb))) {
                /* Can't log this */
                errno = ENOMEM;
                goto fail;
        }
        tdb_io_init(tdb);
        tdb->fd = -1;
        tdb->name = NULL;
        tdb->map_ptr = NULL;
        tdb->flags = tdb_flags;
        tdb->open_flags = open_flags;
        if (log_ctx) {
                tdb->log = *log_ctx;
        } else {
                tdb->log.log_fn = null_log_fn;
                tdb->log.log_private = NULL;
        }
        tdb->hash_fn = hash_fn ? hash_fn : default_tdb_hash;

        /* cache the page size */
        tdb->page_size = getpagesize();
        if (tdb->page_size <= 0) {
                tdb->page_size = 0x2000;
        }

        if ((open_flags & O_ACCMODE) == O_WRONLY) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: can't open tdb %s write-only\n",
                         name));
                errno = EINVAL;
                goto fail;
        }
        
        if (hash_size == 0)
                hash_size = DEFAULT_HASH_SIZE;
        if ((open_flags & O_ACCMODE) == O_RDONLY) {
                tdb->read_only = 1;
                /* read only databases don't do locking or clear if first */
                tdb->flags |= TDB_NOLOCK;
                tdb->flags &= ~TDB_CLEAR_IF_FIRST;
        }

        /* internal databases don't mmap or lock, and start off cleared */
        if (tdb->flags & TDB_INTERNAL) {
                tdb->flags |= (TDB_NOLOCK | TDB_NOMMAP);
                tdb->flags &= ~TDB_CLEAR_IF_FIRST;
                if (tdb_new_database(tdb, hash_size) != 0) {
                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: tdb_new_database failed!"));
                        goto fail;
                }
                goto internal;
        }

        if ((tdb->fd = open(name, open_flags, mode)) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_open_ex: could not open file %s: %s\n",
                         name, strerror(errno)));
                goto fail;      /* errno set by open(2) */
        }

        /* ensure there is only one process initialising at once */
        if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to get global lock on %s: %s\n",
                         name, strerror(errno)));
                goto fail;      /* errno set by tdb_brlock */
        }

        /* we need to zero database if we are the only one with it open */
        if ((tdb_flags & TDB_CLEAR_IF_FIRST) &&
            (locked = (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0, 1) == 0))) {
                open_flags |= O_CREAT;
                if (ftruncate(tdb->fd, 0) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_open_ex: "
                                 "failed to truncate %s: %s\n",
                                 name, strerror(errno)));
                        goto fail; /* errno set by ftruncate */
                }
        }

        errno = 0;
        if (read(tdb->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
            || strcmp(tdb->header.magic_food, TDB_MAGIC_FOOD) != 0
            || (tdb->header.version != TDB_VERSION
                && !(rev = (tdb->header.version==TDB_BYTEREV(TDB_VERSION))))) {
                /* its not a valid database - possibly initialise it */
                if (!(open_flags & O_CREAT) || tdb_new_database(tdb, hash_size) == -1) {
                        if (errno == 0) {
                                errno = EIO; /* ie bad format or something */
                        }
                        goto fail;
                }
                rev = (tdb->flags & TDB_CONVERT);
        }
        vp = (unsigned char *)&tdb->header.version;
        vertest = (((u32)vp[0]) << 24) | (((u32)vp[1]) << 16) |
                  (((u32)vp[2]) << 8) | (u32)vp[3];
        tdb->flags |= (vertest==TDB_VERSION) ? TDB_BIGENDIAN : 0;
        if (!rev)
                tdb->flags &= ~TDB_CONVERT;
        else {
                tdb->flags |= TDB_CONVERT;
                tdb_convert(&tdb->header, sizeof(tdb->header));
        }
        if (fstat(tdb->fd, &st) == -1)
                goto fail;

        if (tdb->header.rwlocks != 0) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: spinlocks no longer supported\n"));
                goto fail;
        }

        /* Is it already in the open list?  If so, fail. */
        if (tdb_already_open(st.st_dev, st.st_ino)) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: "
                         "%s (%d,%d) is already open in this process\n",
                         name, (int)st.st_dev, (int)st.st_ino));
                errno = EBUSY;
                goto fail;
        }

        if (!(tdb->name = (char *)strdup(name))) {
                errno = ENOMEM;
                goto fail;
        }

        tdb->map_size = st.st_size;
        tdb->device = st.st_dev;
        tdb->inode = st.st_ino;
        tdb->max_dead_records = 0;
        tdb_mmap(tdb);
        if (locked) {
                if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_UNLCK, F_SETLK, 0, 1) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: "
                                 "failed to take ACTIVE_LOCK on %s: %s\n",
                                 name, strerror(errno)));
                        goto fail;
                }

        }

        /* We always need to do this if the CLEAR_IF_FIRST flag is set, even if
           we didn't get the initial exclusive lock as we need to let all other
           users know we're using it. */

        if (tdb_flags & TDB_CLEAR_IF_FIRST) {
                /* leave this lock in place to indicate it's in use */
                if (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)
                        goto fail;
        }

        /* if needed, run recovery */
        if (tdb_transaction_recover(tdb) == -1) {
                goto fail;
        }

 internal:
        /* Internal (memory-only) databases skip all the code above to
         * do with disk files, and resume here by releasing their
         * global lock and hooking into the active list. */
        if (tdb->methods->tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1) == -1)
                goto fail;
        tdb->next = tdbs;
        tdbs = tdb;
        return tdb;

 fail:
        { int save_errno = errno;

        if (!tdb)
                return NULL;
        
        if (tdb->map_ptr) {
                if (tdb->flags & TDB_INTERNAL)
                        SAFE_FREE(tdb->map_ptr);
                else
                        tdb_munmap(tdb);
        }
        SAFE_FREE(tdb->name);
        if (tdb->fd != -1)
                if (close(tdb->fd) != 0)
                        TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_open_ex: failed to close tdb->fd on error!\n"));
        SAFE_FREE(tdb);
        errno = save_errno;
        return NULL;
        }
}

void tdb_set_max_dead	(	struct tdb_context *	tdb,
		int	max_dead
	)

open.c の 346 行で定義されています。

参照先 tdb_context::max_dead_records・tdb.

参照元 brl_init()・locking_init()・message_init().

{
        tdb->max_dead_records = max_dead;
}

int tdb_reopen

(

struct tdb_context *

tdb

)

open.c の 404 行で定義されています。

参照先 tdb_lock_type::count・tdb_context::device・errno・tdb_context::fd・tdb_context::flags・tdb_context::global_lock・tdb_context::inode・tdb_context::methods・tdb_context::name・tdb_context::num_locks・tdb_context::open_flags・strerror()・tdb・tdb_methods::tdb_brlock・tdb_close()・TDB_DEBUG_ERROR・TDB_DEBUG_FATAL・tdb_mmap()・tdb_munmap()・tdb_context::transaction.

参照元 tdb_reopen_all()・wins_write_database().

{
        struct stat st;

        if (tdb->flags & TDB_INTERNAL) {
                return 0; /* Nothing to do. */
        }

        if (tdb->num_locks != 0 || tdb->global_lock.count) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_reopen: reopen not allowed with locks held\n"));
                goto fail;
        }

        if (tdb->transaction != 0) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_reopen: reopen not allowed inside a transaction\n"));
                goto fail;
        }

        if (tdb_munmap(tdb) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: munmap failed (%s)\n", strerror(errno)));
                goto fail;
        }
        if (close(tdb->fd) != 0)
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: WARNING closing tdb->fd failed!\n"));
        tdb->fd = open(tdb->name, tdb->open_flags & ~(O_CREAT|O_TRUNC), 0);
        if (tdb->fd == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: open failed (%s)\n", strerror(errno)));
                goto fail;
        }
        if ((tdb->flags & TDB_CLEAR_IF_FIRST) && 
            (tdb->methods->tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1)) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: failed to obtain active lock\n"));
                goto fail;
        }
        if (fstat(tdb->fd, &st) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: fstat failed (%s)\n", strerror(errno)));
                goto fail;
        }
        if (st.st_ino != tdb->inode || st.st_dev != tdb->device) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_reopen: file dev/inode has changed!\n"));
                goto fail;
        }
        tdb_mmap(tdb);

        return 0;

fail:
        tdb_close(tdb);
        return -1;
}

int tdb_reopen_all

(

int

parent_longlived

)

open.c の 456 行で定義されています。

参照先 tdb_context::flags・tdb_context::next・tdb・tdb_reopen()・tdbs.

参照元 addrec_db()・fork_child_dc_connect()・fork_domain_child()・open_sockets_smbd().

{
        struct tdb_context *tdb;

        for (tdb=tdbs; tdb; tdb = tdb->next) {
                /*
                 * If the parent is longlived (ie. a
                 * parent daemon architecture), we know
                 * it will keep it's active lock on a
                 * tdb opened with CLEAR_IF_FIRST. Thus
                 * for child processes we don't have to
                 * add an active lock. This is essential
                 * to improve performance on systems that
                 * keep POSIX locks as a non-scalable data
                 * structure in the kernel.
                 */
                if (parent_longlived) {
                        /* Ensure no clear-if-first. */
                        tdb->flags &= ~TDB_CLEAR_IF_FIRST;
                }

                if (tdb_reopen(tdb) != 0)
                        return -1;
        }

        return 0;
}

void tdb_set_logging_function	(	struct tdb_context *	tdb,
		const struct tdb_logging_context *	log_ctx
	)

open.c の 391 行で定義されています。

参照先 tdb_context::log・tdb.

{
        tdb->log = *log_ctx;
}

enum TDB_ERROR tdb_error

(

struct tdb_context *

tdb

)

error.c の 31 行で定義されています。

参照先 tdb_context::ecode・tdb.

参照元 allocate_print_jobid()・tdb_change_int32_atomic()・tdb_change_uint32_atomic()・yield_connection().

{
        return tdb->ecode;
}

const char* tdb_errorstr

(

struct tdb_context *

tdb

)

error.c の 50 行で定義されています。

参照先 tdb_errname::ecode・tdb_context::ecode・emap・tdb_errname::estring・tdb.

参照元 claim_connection()・count_current_connections()・count_fn()・idmap_tdb_remove_mapping()・idmap_tdb_set_mapping()・info_tdb()・initialize_winbindd_cache()・net_enum_pipes()・register_message_flags()・tdb_ass_subscript()・tdb_delete_samacct_only()・tdb_update_ridrec_only()・tdb_update_samacct_only()・tdbsam_delete_sam_account()・tdbsam_getsampwnam()・tdbsam_getsampwrid()・upgrade_to_version_3()・yield_connection().

{
        u32 i;
        for (i = 0; i < sizeof(emap) / sizeof(struct tdb_errname); i++)
                if (tdb->ecode == emap[i].ecode)
                        return emap[i].estring;
        return "Invalid error code";
}

TDB_DATA tdb_fetch	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 TDB_DATA::dptr・tdb_context::hash_fn・tdb・tdb_alloc_read()・tdb_find_lock_hash()・tdb_null・tdb_unlock().

参照元 _reg_perfcount_assemble_global()・_reg_perfcount_get_64()・_reg_perfcount_get_counter_data()・_reg_perfcount_get_counter_info()・_reg_perfcount_get_instance_info()・_reg_perfcount_get_numinst()・_reg_perfcount_multi_sz_from_tdb()・add_aliasmem()・add_fd_to_close_entry()・addrec_db()・brl_get_locks_internal()・cache_retrieve_response()・compare_db()・decrement_windows_lock_ref_count()・delete_printer_driver()・dump_tdb()・enum_group_mapping()・find_name_on_wins_subnet()・first_record()・gencache_get()・gencache_iterate()・get_a_printer_2()・get_a_printer_driver_3()・get_eventlog_record()・get_group_map_from_gid()・get_group_map_from_ntname()・get_group_map_from_sid()・get_jobs_changed_data()・get_ntforms()・get_posix_pending_close_entries()・get_privileges()・get_queue_status()・get_share_mode_lock()・get_stored_queue_info()・get_updating_pid()・get_windows_lock_ref_count()・group_map_remove()・idmap_cache_map_id()・idmap_cache_map_sid()・idmap_tdb_id_to_sid()・idmap_tdb_remove_mapping()・idmap_tdb_set_mapping()・idmap_tdb_sid_to_id()・increment_windows_lock_ref_count()・lang_msg()・login_cache_read()・make_way_for_eventlogs()・message_send_pid_internal()・messages_pending_for_pid()・move_rec()・netsamlogon_cache_get()・next_record()・one_alias_membership()・pjob_store()・pjobid_to_rap()・print_job_find()・print_queue_status()・rap_jobid_delete()・rap_to_pjobid()・reduce_windows_lock_ref_count()・reg_perfcount_get_base_index()・register_message_flags()・remove_from_jobs_changed()・retrieve_all_messages()・secrets_fetch()・session_yield()・set_driver_init_2()・show_tdb()・smb_change_share_mode_entry()・smb_create_share_mode_entry_ex()・smb_delete_share_mode_entry()・smb_get_share_mode_entries()・tdb_append()・tdb_fetch_bystring()・tdb_fetch_int32_byblob()・tdb_fetch_uint32_byblob()・tdb_hnd_subscript()・tdbsam_convert()・tdbsam_getsampwent()・tdbsam_getsampwnam()・tdbsam_getsampwrid()・upgrade_to_version_3()・wcache_cached_creds_exist()・wcache_fetch_raw()・wcache_remove_oldest_cached_creds().

{
        tdb_off_t rec_ptr;
        struct list_struct rec;
        TDB_DATA ret;
        u32 hash;

        /* find which hash bucket it is in */
        hash = tdb->hash_fn(&key);
        if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec)))
                return tdb_null;

        ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
                                  rec.data_len);
        ret.dsize = rec.data_len;
        tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
        return ret;
}

int tdb_parse_record	(	struct tdb_context *	tdb,
		TDB_DATA	key,
		int(*)(TDB_DATA key, TDB_DATA data, void *private_data)	parser,
		void *	private_data
	)

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

参照先 tdb_context::hash_fn・tdb・TDB_ERR_NOEXIST・tdb_find_lock_hash()・tdb_parse_data()・tdb_unlock().

参照元 get_delete_on_close_flag().

{
        tdb_off_t rec_ptr;
        struct list_struct rec;
        int ret;
        u32 hash;

        /* find which hash bucket it is in */
        hash = tdb->hash_fn(&key);

        if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
                return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
        }

        ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
                             rec.data_len, parser, private_data);

        tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);

        return ret;
}

int tdb_delete	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_delete_hash().

参照元 addrec_db()・byte_range_lock_destructor()・cache_cleanup_response()・cache_store_response()・convert_fn()・count_fn()・cull_traverse()・del_a_printer()・del_aliasmem()・del_driver_init()・delete_a_form()・delete_close_entries()・delete_pipe_opendb()・delete_printer_driver()・delete_tdb()・delete_windows_lock_ref_count()・do_delete_fn()・gencache_del()・gencache_get()・group_map_remove()・idmap_cache_del()・idmap_cache_map_id()・idmap_cache_map_sid()・idmap_tdb_remove_mapping()・idmap_tdb_set_mapping()・login_cache_delentry()・merge_test()・message_notify()・netsamlogon_cache_get()・netsamlogon_clear_cached_user()・normalize_printers_fn()・pjob_delete()・rap_jobid_delete()・remove_name_from_wins_namelist()・sec_desc_upg_fn()・secrets_delete()・session_claim()・session_yield()・set_updating_pid()・share_mode_lock_destructor()・smb_delete_share_mode_entry()・tdb_ass_subscript()・tdb_delete_bystring()・tdb_delete_samacct_only()・tdb_trans_delete()・tdb_traverse_delete_fn()・tdbsam_delete_sam_account()・traverse_fn()・traverse_fn_cleanup()・upgrade_to_version_3()・wcache_delete()・wcache_remove_oldest_cached_creds()・yield_connection().

{
        u32 hash = tdb->hash_fn(&key);
        return tdb_delete_hash(tdb, key, hash);
}

int tdb_store	(	struct tdb_context *	tdb,
		TDB_DATA	key,
		TDB_DATA	dbuf,
		int	flag
	)

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

参照先 list_struct::data_len・TDB_DATA::dptr・TDB_DATA::dsize・tdb_context::ecode・list_struct::full_hash・tdb_context::hash_fn・list_struct::key_len・list_struct::magic・list_struct::next・tdb_context::read_only・tdb・tdb_allocate()・tdb_delete_hash()・TDB_ERR_EXISTS・TDB_ERR_NOEXIST・TDB_ERR_OOM・TDB_ERR_RDONLY・tdb_exists_hash()・tdb_find_dead()・tdb_increment_seqnum()・tdb_lock()・tdb_ofs_read()・tdb_ofs_write()・tdb_purge_dead()・tdb_rec_write()・TDB_SUCCESS・tdb_unlock()・tdb_update_hash()・tdb_context::traverse_read.

参照元 add_a_printer_driver_3()・add_aliasmem()・add_fd_to_close_entry()・add_mapping_entry()・addrec_db()・byte_range_lock_destructor()・cache_store_response()・centry_end()・claim_connection()・convert_fn()・copy_fn()・decrement_windows_lock_ref_count()・del_aliasmem()・gencache_set()・idmap_cache_set()・idmap_cache_set_negative_id()・idmap_cache_set_negative_sid()・idmap_tdb_set_mapping()・increment_windows_lock_ref_count()・insert_tdb()・load_msg()・login_cache_write()・merge_test()・message_send_pid_internal()・move_rec()・normalize_printers_fn()・pjob_store()・pjobid_to_rap()・print_queue_update_internal()・reduce_windows_lock_ref_count()・regdb_store_keys_internal()・register_message_flags()・remove_from_jobs_changed()・retrieve_all_messages()・seen_insert()・session_claim()・set_privileges()・set_updating_pid()・share_mode_lock_destructor()・smb_change_share_mode_entry()・smb_create_share_mode_entry_ex()・smb_delete_share_mode_entry()・store_or_replace_wins_namerec()・store_pipe_opendb()・store_queue_struct()・store_tdb()・tdb_append()・tdb_ass_subscript()・tdb_store_bystring()・tdb_store_int32_byblob()・tdb_store_uint32_byblob()・tdb_trans_store()・tdb_update_ridrec_only()・tdb_update_samacct_only()・tdbsam_convert()・traverse_fn()・unexpected_packet()・update_a_printer_2()・update_driver_init_2()・upgrade_to_version_3()・write_eventlog_tdb()・write_ntforms().

{
        struct list_struct rec;
        u32 hash;
        tdb_off_t rec_ptr;
        char *p = NULL;
        int ret = -1;

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

        /* find which hash bucket it is in */
        hash = tdb->hash_fn(&key);
        if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
                return -1;

        /* check for it existing, on insert. */
        if (flag == TDB_INSERT) {
                if (tdb_exists_hash(tdb, key, hash)) {
                        tdb->ecode = TDB_ERR_EXISTS;
                        goto fail;
                }
        } else {
                /* first try in-place update, on modify or replace. */
                if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
                        goto done;
                }
                if (tdb->ecode == TDB_ERR_NOEXIST &&
                    flag == TDB_MODIFY) {
                        /* if the record doesn't exist and we are in TDB_MODIFY mode then
                         we should fail the store */
                        goto fail;
                }
        }
        /* reset the error code potentially set by the tdb_update() */
        tdb->ecode = TDB_SUCCESS;

        /* delete any existing record - if it doesn't exist we don't
           care.  Doing this first reduces fragmentation, and avoids
           coalescing with `allocated' block before it's updated. */
        if (flag != TDB_INSERT)
                tdb_delete_hash(tdb, key, hash);

        /* Copy key+value *before* allocating free space in case malloc
           fails and we are left with a dead spot in the tdb. */

        if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
                tdb->ecode = TDB_ERR_OOM;
                goto fail;
        }

        memcpy(p, key.dptr, key.dsize);
        if (dbuf.dsize)
                memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);

        if (tdb->max_dead_records != 0) {
                /*
                 * Allow for some dead records per hash chain, look if we can
                 * find one that can hold the new record. We need enough space
                 * for key, data and tailer. If we find one, we don't have to
                 * consult the central freelist.
                 */
                rec_ptr = tdb_find_dead(
                        tdb, hash, &rec,
                        key.dsize + dbuf.dsize + sizeof(tdb_off_t));

                if (rec_ptr != 0) {
                        rec.key_len = key.dsize;
                        rec.data_len = dbuf.dsize;
                        rec.full_hash = hash;
                        rec.magic = TDB_MAGIC;
                        if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
                            || tdb->methods->tdb_write(
                                    tdb, rec_ptr + sizeof(rec),
                                    p, key.dsize + dbuf.dsize) == -1) {
                                goto fail;
                        }
                        goto done;
                }
        }

        /*
         * We have to allocate some space from the freelist, so this means we
         * have to lock it. Use the chance to purge all the DEAD records from
         * the hash chain under the freelist lock.
         */

        if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
                goto fail;
        }

        if ((tdb->max_dead_records != 0)
            && (tdb_purge_dead(tdb, hash) == -1)) {
                tdb_unlock(tdb, -1, F_WRLCK);
                goto fail;
        }

        /* we have to allocate some space */
        rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);

        tdb_unlock(tdb, -1, F_WRLCK);

        if (rec_ptr == 0) {
                goto fail;
        }

        /* Read hash top into next ptr */
        if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
                goto fail;

        rec.key_len = key.dsize;
        rec.data_len = dbuf.dsize;
        rec.full_hash = hash;
        rec.magic = TDB_MAGIC;

        /* write out and point the top of the hash chain at it */
        if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
            || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
            || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
                /* Need to tdb_unallocate() here */
                goto fail;
        }

 done:
        ret = 0;
 fail:
        if (ret == 0) {
                tdb_increment_seqnum(tdb);
        }

        SAFE_FREE(p); 
        tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
        return ret;
}

int tdb_append	(	struct tdb_context *	tdb,
		TDB_DATA	key,
		TDB_DATA	new_dbuf
	)

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

参照先 TDB_DATA::dptr・TDB_DATA::dsize・tdb_context::ecode・failed・tdb_context::hash_fn・tdb・TDB_ERR_OOM・tdb_fetch()・tdb_lock()・tdb_store()・tdb_unlock().

参照元 add_to_jobs_changed()・addrec_db()・message_send_pid_internal().

{
        u32 hash;
        TDB_DATA dbuf;
        int ret = -1;

        /* find which hash bucket it is in */
        hash = tdb->hash_fn(&key);
        if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
                return -1;

        dbuf = tdb_fetch(tdb, key);

        if (dbuf.dptr == NULL) {
                dbuf.dptr = (char *)malloc(new_dbuf.dsize);
        } else {
                char *new_dptr = (char *)realloc(dbuf.dptr,
                                            dbuf.dsize + new_dbuf.dsize);
                if (new_dptr == NULL) {
                        free(dbuf.dptr);
                }
                dbuf.dptr = new_dptr;
        }

        if (dbuf.dptr == NULL) {
                tdb->ecode = TDB_ERR_OOM;
                goto failed;
        }

        memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
        dbuf.dsize += new_dbuf.dsize;

        ret = tdb_store(tdb, key, dbuf, 0);
        
failed:
        tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
        SAFE_FREE(dbuf.dptr);
        return ret;
}

int tdb_close

(

struct tdb_context *

tdb

)

Close a database.

戻り値:

-1 for error; 0 for success.

open.c の 356 行で定義されています。

参照先 tdb_context::fd・tdb_context::flags・tdb_context::lockrecs・tdb_context::map_ptr・tdb_context::name・tdb_context::next・tdb・tdb_munmap()・tdb_transaction_cancel()・tdbs・tdb_context::transaction.

参照元 _reg_perfcount_get_counter_data()・_reg_perfcount_init_data_block_perf()・backup_tdb()・brl_shutdown()・close_all_print_db()・create_tdb()・do_daemon_stack_trace()・do_winbind_offline()・do_winbind_online()・elog_close_tdb()・gencache_shutdown()・idmap_cache_destructor()・idmap_tdb_convert()・idmap_tdb_open_db()・idmap_tdb_tdb_close()・initialize_winbindd_cache()・lang_tdb_init()・locking_end()・login_cache_shutdown()・main()・move_rec()・net_idmap_dump()・net_status_sessions()・net_status_shares()・net_status_shares_parseable()・netsamlogon_cache_shutdown()・netsamlogon_clear_cached_user()・nt_printing_init()・open_schannel_session_store()・open_tdb()・posix_locking_end()・py_tdb_close()・receive_unexpected()・reg_perfcount_get_base_index()・reg_perfcount_get_counter_help()・reg_perfcount_get_counter_names()・reg_perfcount_get_perf_data_block()・regdb_close()・reset_stat_cache()・secrets_restore_schannel_session_info()・secrets_store_schannel_session_info()・send_message()・send_repl_message()・send_sync_message()・smb_share_mode_db_close()・status_page()・tdb_hnd_dealloc()・tdb_reopen()・tdb_validate_freelist()・tdb_wrap_destructor()・tdbsam_close()・tdbsam_new_rid()・tdbsam_open()・verify_tdb()・wcache_flush_cache().

{
        struct tdb_context **i;
        int ret = 0;

        if (tdb->transaction) {
                tdb_transaction_cancel(tdb);
        }

        if (tdb->map_ptr) {
                if (tdb->flags & TDB_INTERNAL)
                        SAFE_FREE(tdb->map_ptr);
                else
                        tdb_munmap(tdb);
        }
        SAFE_FREE(tdb->name);
        if (tdb->fd != -1)
                ret = close(tdb->fd);
        SAFE_FREE(tdb->lockrecs);

        /* Remove from contexts list */
        for (i = &tdbs; *i; i = &(*i)->next) {
                if (*i == tdb) {
                        *i = tdb->next;
                        break;
                }
        }

        memset(tdb, 0, sizeof(*tdb));
        SAFE_FREE(tdb);

        return ret;
}

TDB_DATA tdb_firstkey

(

struct tdb_context *

tdb

)

traverse.c の 255 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・tdb_traverse_lock::hash・list_struct::key_len・tdb_traverse_lock::lock_rw・tdb_traverse_lock::off・tdb・tdb_alloc_read()・TDB_DEBUG_FATAL・tdb_next_lock()・tdb_null・tdb_unlock()・tdb_unlock_record()・tdb_context::travlocks.

参照元 compare_db()・enum_group_mapping()・first_record()・get_group_map_from_gid()・get_group_map_from_ntname()・get_ntdrivers()・get_ntforms()・py_tdb_hnd_first_key()・tdb_search_keys()・tdbsam_convert()・upgrade_to_version_3().

{
        TDB_DATA key;
        struct list_struct rec;

        /* release any old lock */
        if (tdb_unlock_record(tdb, tdb->travlocks.off) != 0)
                return tdb_null;
        tdb->travlocks.off = tdb->travlocks.hash = 0;
        tdb->travlocks.lock_rw = F_RDLCK;

        /* Grab first record: locks chain and returned record. */
        if (tdb_next_lock(tdb, &tdb->travlocks, &rec) <= 0)
                return tdb_null;
        /* now read the key */
        key.dsize = rec.key_len;
        key.dptr =tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);

        /* Unlock the hash chain of the record we just read. */
        if (tdb_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_firstkey: error occurred while tdb_unlocking!\n"));
        return key;
}

TDB_DATA tdb_nextkey	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

traverse.c の 280 行で定義されています。

参照先 TDB_DATA::dptr・TDB_DATA::dsize・errno・list_struct::full_hash・tdb_traverse_lock::hash・tdb_context::hash_fn・list_struct::key_len・tdb_traverse_lock::lock_rw・tdb_traverse_lock::off・strerror()・tdb・tdb_alloc_read()・TDB_DEBUG_FATAL・tdb_find_lock_hash()・tdb_lock()・tdb_lock_record()・tdb_next_lock()・tdb_null・tdb_rec_read()・tdb_unlock()・tdb_unlock_record()・tdb_context::travlocks.

参照元 compare_db()・enum_group_mapping()・get_group_map_from_gid()・get_group_map_from_ntname()・get_ntdrivers()・get_ntforms()・next_record()・py_tdb_hnd_next_key()・tdb_search_keys()・tdbsam_convert()・upgrade_to_version_3().

{
        u32 oldhash;
        TDB_DATA key = tdb_null;
        struct list_struct rec;
        char *k = NULL;

        /* Is locked key the old key?  If so, traverse will be reliable. */
        if (tdb->travlocks.off) {
                if (tdb_lock(tdb,tdb->travlocks.hash,tdb->travlocks.lock_rw))
                        return tdb_null;
                if (tdb_rec_read(tdb, tdb->travlocks.off, &rec) == -1
                    || !(k = tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),
                                            rec.key_len))
                    || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
                        /* No, it wasn't: unlock it and start from scratch */
                        if (tdb_unlock_record(tdb, tdb->travlocks.off) != 0) {
                                SAFE_FREE(k);
                                return tdb_null;
                        }
                        if (tdb_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0) {
                                SAFE_FREE(k);
                                return tdb_null;
                        }
                        tdb->travlocks.off = 0;
                }

                SAFE_FREE(k);
        }

        if (!tdb->travlocks.off) {
                /* No previous element: do normal find, and lock record */
                tdb->travlocks.off = tdb_find_lock_hash(tdb, oldkey, tdb->hash_fn(&oldkey), tdb->travlocks.lock_rw, &rec);
                if (!tdb->travlocks.off)
                        return tdb_null;
                tdb->travlocks.hash = BUCKET(rec.full_hash);
                if (tdb_lock_record(tdb, tdb->travlocks.off) != 0) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_nextkey: lock_record failed (%s)!\n", strerror(errno)));
                        return tdb_null;
                }
        }
        oldhash = tdb->travlocks.hash;

        /* Grab next record: locks chain and returned record,
           unlocks old record */
        if (tdb_next_lock(tdb, &tdb->travlocks, &rec) > 0) {
                key.dsize = rec.key_len;
                key.dptr = tdb_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
                                          key.dsize);
                /* Unlock the chain of this new record */
                if (tdb_unlock(tdb, tdb->travlocks.hash, tdb->travlocks.lock_rw) != 0)
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
        }
        /* Unlock the chain of old record */
        if (tdb_unlock(tdb, BUCKET(oldhash), tdb->travlocks.lock_rw) != 0)
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
        return key;
}

int tdb_traverse	(	struct tdb_context *	tdb,
		tdb_traverse_func	fn,
		void *
	)

traverse.c の 230 行で定義されています。

参照先 tdb_context::ecode・tdb_context::methods・tdb_context::read_only・tdb・tdb_methods::tdb_brlock・TDB_DEBUG_ERROR・TDB_ERR_LOCK・tdb_traverse_internal()・tdb_traverse_read()・tdb_context::traverse_read.

参照元 addrec_db()・backup_tdb()・brl_forall()・clear_unexpected()・count_current_connections()・do_command()・do_daemon_stack_trace()・dump_tdb()・dump_wins_subnet_namelist()・elog_tdb_size()・enum_aliasmem()・fetch_all_active_wins_1b_names()・idmap_tdb_convert()・idmap_tdb_dump_data()・info_tdb()・init_group_mapping()・initiate_wins_processing()・load_msg()・main()・message_send_all()・net_enum_pipes()・net_idmap_dump()・net_status_sessions()・net_status_shares()・net_status_shares_parseable()・print_backend_init()・print_queue_update_internal()・privilege_enumerate_accounts()・py_tdb_hnd_keys()・py_tdb_hnd_traverse()・receive_unexpected()・session_traverse()・share_info_db_init()・share_mode_forall()・status_page()・sysjob_to_jobid()・tdb_hnd_length()・tdbsam_setsampwent()・update_c_setprinter()・upgrade_to_version_4()・upgrade_to_version_5()・verify_tdb()・wcache_count_cached_creds()・wcache_flush_cache()・wcache_invalidate_cache()・wcache_remove_oldest_cached_creds()・wins_write_database().

{
        struct tdb_traverse_lock tl = { NULL, 0, 0, F_WRLCK };
        int ret;

        if (tdb->read_only || tdb->traverse_read) {
                return tdb_traverse_read(tdb, fn, private_data);
        }
        
        if (tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_traverse: failed to get transaction lock\n"));
                tdb->ecode = TDB_ERR_LOCK;
                return -1;
        }

        ret = tdb_traverse_internal(tdb, fn, private_data, &tl);

        tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);

        return ret;
}

int tdb_traverse_read	(	struct tdb_context *	tdb,
		tdb_traverse_func	fn,
		void *
	)

traverse.c の 203 行で定義されています。

参照先 tdb_context::ecode・tdb_context::methods・tdb・tdb_methods::tdb_brlock・TDB_DEBUG_ERROR・TDB_ERR_LOCK・tdb_traverse_internal()・tdb_context::traverse_read.

参照元 addrec_db()・main()・tdb_traverse().

{
        struct tdb_traverse_lock tl = { NULL, 0, 0, F_RDLCK };
        int ret;
        
        /* we need to get a read lock on the transaction lock here to
           cope with the lock ordering semantics of solaris10 */
        if (tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_RDLCK, F_SETLKW, 0, 1) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_traverse_read: failed to get transaction lock\n"));
                tdb->ecode = TDB_ERR_LOCK;
                return -1;
        }

        tdb->traverse_read++;
        ret = tdb_traverse_internal(tdb, fn, private_data, &tl);
        tdb->traverse_read--;

        tdb->methods->tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);

        return ret;
}

int tdb_exists	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_exists_hash().

参照元 print_job_exists()・py_tdb_hnd_has_key().

{
        u32 hash = tdb->hash_fn(&key);
        return tdb_exists_hash(tdb, key, hash);
}

int tdb_lockall

(

struct tdb_context *

tdb

)

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

参照先 _tdb_lockall()・tdb.

参照元 backup_tdb()・load_msg()・py_tdb_hnd_lock_all().

{
        return _tdb_lockall(tdb, F_WRLCK);
}

int tdb_unlockall

(

struct tdb_context *

tdb

)

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

参照先 _tdb_unlockall()・tdb.

参照元 load_msg()・py_tdb_hnd_unlock_all().

{
        return _tdb_unlockall(tdb, F_WRLCK);
}

int tdb_lockall_read

(

struct tdb_context *

tdb

)

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

参照先 _tdb_lockall()・tdb.

{
        return _tdb_lockall(tdb, F_RDLCK);
}

int tdb_unlockall_read

(

struct tdb_context *

tdb

)

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

参照先 _tdb_unlockall()・tdb.

{
        return _tdb_unlockall(tdb, F_RDLCK);
}

const char* tdb_name

(

struct tdb_context *

tdb

)

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

参照先 tdb_context::name・tdb.

参照元 _reg_perfcount_multi_sz_from_tdb()・copy_fn()・tdb_chainlock_with_timeout_internal()・tdb_log()・tdb_wrap_log().

{
        return tdb->name;
}

int tdb_fd

(

struct tdb_context *

tdb

)

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

参照先 tdb_context::fd・tdb.

参照元 backup_tdb()・winbindd_check_cache_size().

{
        return tdb->fd;
}

tdb_log_func tdb_log_fn

(

struct tdb_context *

tdb

)

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

参照先 tdb_context::log・tdb_logging_context::log_fn・tdb.

{
        return tdb->log.log_fn;
}

void* tdb_get_logging_private

(

struct tdb_context *

tdb

)

open.c の 397 行で定義されています。

参照先 tdb_context::log・tdb_logging_context::log_private・tdb.

{
        return tdb->log.log_private;
}

int tdb_transaction_start

(

struct tdb_context *

tdb

)

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

参照先 tdb_lock_type::count・tdb_context::ecode・tdb_context::flags・tdb_context::global_lock・tdb_transaction::hash_heads・tdb_header::hash_size・tdb_context::header・tdb_transaction::io_methods・tdb_context::map_size・tdb_context::methods・tdb_transaction::nesting・tdb_traverse_lock::next・tdb_context::num_locks・tdb_transaction::old_map_size・tdb_context::read_only・tdb・tdb_brlock()・TDB_DEBUG_ERROR・TDB_DEBUG_FATAL・TDB_DEBUG_TRACE・TDB_ERR_EINVAL・TDB_ERR_IO・TDB_ERR_LOCK・TDB_ERR_OOM・tdb_methods::tdb_oob・tdb_methods::tdb_read・tdb_context::transaction・transaction_methods・transaction_write()・tdb_context::traverse_read・tdb_context::travlocks.

参照元 addrec_db()・init_registry_data()・tdb_trans_delete()・tdb_trans_store().

{
        /* some sanity checks */
        if (tdb->read_only || (tdb->flags & TDB_INTERNAL) || tdb->traverse_read) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: cannot start a transaction on a read-only or internal db\n"));
                tdb->ecode = TDB_ERR_EINVAL;
                return -1;
        }

        /* cope with nested tdb_transaction_start() calls */
        if (tdb->transaction != NULL) {
                tdb->transaction->nesting++;
                TDB_LOG((tdb, TDB_DEBUG_TRACE, "tdb_transaction_start: nesting %d\n", 
                         tdb->transaction->nesting));
                return 0;
        }

        if (tdb->num_locks != 0 || tdb->global_lock.count) {
                /* the caller must not have any locks when starting a
                   transaction as otherwise we'll be screwed by lack
                   of nested locks in posix */
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: cannot start a transaction with locks held\n"));
                tdb->ecode = TDB_ERR_LOCK;
                return -1;
        }

        if (tdb->travlocks.next != NULL) {
                /* you cannot use transactions inside a traverse (although you can use
                   traverse inside a transaction) as otherwise you can end up with
                   deadlock */
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: cannot start a transaction within a traverse\n"));
                tdb->ecode = TDB_ERR_LOCK;
                return -1;
        }

        tdb->transaction = (struct tdb_transaction *)
                calloc(sizeof(struct tdb_transaction), 1);
        if (tdb->transaction == NULL) {
                tdb->ecode = TDB_ERR_OOM;
                return -1;
        }

        /* get the transaction write lock. This is a blocking lock. As
           discussed with Volker, there are a number of ways we could
           make this async, which we will probably do in the future */
        if (tdb_brlock(tdb, TRANSACTION_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: failed to get transaction lock\n"));
                tdb->ecode = TDB_ERR_LOCK;
                SAFE_FREE(tdb->transaction);
                return -1;
        }
        
        /* get a read lock from the freelist to the end of file. This
           is upgraded to a write lock during the commit */
        if (tdb_brlock(tdb, FREELIST_TOP, F_RDLCK, F_SETLKW, 0, 0) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: failed to get hash locks\n"));
                tdb->ecode = TDB_ERR_LOCK;
                goto fail;
        }

        /* setup a copy of the hash table heads so the hash scan in
           traverse can be fast */
        tdb->transaction->hash_heads = (u32 *)
                calloc(tdb->header.hash_size+1, sizeof(u32));
        if (tdb->transaction->hash_heads == NULL) {
                tdb->ecode = TDB_ERR_OOM;
                goto fail;
        }
        if (tdb->methods->tdb_read(tdb, FREELIST_TOP, tdb->transaction->hash_heads,
                                   TDB_HASHTABLE_SIZE(tdb), 0) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_start: failed to read hash heads\n"));
                tdb->ecode = TDB_ERR_IO;
                goto fail;
        }

        /* make sure we know about any file expansions already done by
           anyone else */
        tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
        tdb->transaction->old_map_size = tdb->map_size;

        /* finally hook the io methods, replacing them with
           transaction specific methods */
        tdb->transaction->io_methods = tdb->methods;
        tdb->methods = &transaction_methods;

        /* by calling this transaction write here, we ensure that we don't grow the
           transaction linked list due to hash table updates */
        if (transaction_write(tdb, FREELIST_TOP, tdb->transaction->hash_heads, 
                              TDB_HASHTABLE_SIZE(tdb)) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_start: failed to prime hash table\n"));
                tdb->ecode = TDB_ERR_IO;
                goto fail;
        }

        return 0;
        
fail:
        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
        tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);
        SAFE_FREE(tdb->transaction->hash_heads);
        SAFE_FREE(tdb->transaction);
        return -1;
}

int tdb_transaction_commit

(

struct tdb_context *

tdb

)

transaction.c の 783 行で定義されています。

参照先 tdb_lock_type::count・tdb_transaction_el::data・tdb_context::ecode・tdb_transaction::elements・tdb_context::flags・tdb_context::global_lock・tdb_transaction::io_methods・tdb_transaction_el::length・tdb_context::map_size・tdb_context::methods・methods・tdb_context::name・tdb_transaction::nesting・tdb_transaction_el::next・tdb_context::num_locks・tdb_transaction_el::offset・tdb_transaction::old_map_size・tdb・tdb_brlock()・tdb_brlock_upgrade()・TDB_DEBUG_ERROR・TDB_DEBUG_FATAL・TDB_ERR_IO・TDB_ERR_LOCK・tdb_transaction_cancel()・tdb_transaction_recover()・tdb_context::transaction・tdb_transaction::transaction_error・transaction_setup_recovery()・transaction_sync().

参照元 addrec_db()・init_registry_data()・tdb_trans_delete()・tdb_trans_store().

{       
        const struct tdb_methods *methods;
        tdb_off_t magic_offset = 0;
        u32 zero = 0;

        if (tdb->transaction == NULL) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_commit: no transaction\n"));
                return -1;
        }

        if (tdb->transaction->transaction_error) {
                tdb->ecode = TDB_ERR_IO;
                tdb_transaction_cancel(tdb);
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_commit: transaction error pending\n"));
                return -1;
        }

        if (tdb->transaction->nesting != 0) {
                tdb->transaction->nesting--;
                return 0;
        }               

        /* check for a null transaction */
        if (tdb->transaction->elements == NULL) {
                tdb_transaction_cancel(tdb);
                return 0;
        }

        methods = tdb->transaction->io_methods;
        
        /* if there are any locks pending then the caller has not
           nested their locks properly, so fail the transaction */
        if (tdb->num_locks || tdb->global_lock.count) {
                tdb->ecode = TDB_ERR_LOCK;
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_commit: locks pending on commit\n"));
                tdb_transaction_cancel(tdb);
                return -1;
        }

        /* upgrade the main transaction lock region to a write lock */
        if (tdb_brlock_upgrade(tdb, FREELIST_TOP, 0) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_start: failed to upgrade hash locks\n"));
                tdb->ecode = TDB_ERR_LOCK;
                tdb_transaction_cancel(tdb);
                return -1;
        }

        /* get the global lock - this prevents new users attaching to the database
           during the commit */
        if (tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0, 1) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_commit: failed to get global lock\n"));
                tdb->ecode = TDB_ERR_LOCK;
                tdb_transaction_cancel(tdb);
                return -1;
        }

        if (!(tdb->flags & TDB_NOSYNC)) {
                /* write the recovery data to the end of the file */
                if (transaction_setup_recovery(tdb, &magic_offset) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: failed to setup recovery data\n"));
                        tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);
                        tdb_transaction_cancel(tdb);
                        return -1;
                }
        }

        /* expand the file to the new size if needed */
        if (tdb->map_size != tdb->transaction->old_map_size) {
                if (methods->tdb_expand_file(tdb, tdb->transaction->old_map_size, 
                                             tdb->map_size - 
                                             tdb->transaction->old_map_size) == -1) {
                        tdb->ecode = TDB_ERR_IO;
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: expansion failed\n"));
                        tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);
                        tdb_transaction_cancel(tdb);
                        return -1;
                }
                tdb->map_size = tdb->transaction->old_map_size;
                methods->tdb_oob(tdb, tdb->map_size + 1, 1);
        }

        /* perform all the writes */
        while (tdb->transaction->elements) {
                struct tdb_transaction_el *el = tdb->transaction->elements;

                if (methods->tdb_write(tdb, el->offset, el->data, el->length) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed during commit\n"));
                        
                        /* we've overwritten part of the data and
                           possibly expanded the file, so we need to
                           run the crash recovery code */
                        tdb->methods = methods;
                        tdb_transaction_recover(tdb); 

                        tdb_transaction_cancel(tdb);
                        tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);

                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: write failed\n"));
                        return -1;
                }
                tdb->transaction->elements = el->next;
                free(el->data); 
                free(el);
        } 

        if (!(tdb->flags & TDB_NOSYNC)) {
                /* ensure the new data is on disk */
                if (transaction_sync(tdb, 0, tdb->map_size) == -1) {
                        return -1;
                }

                /* remove the recovery marker */
                if (methods->tdb_write(tdb, magic_offset, &zero, 4) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_commit: failed to remove recovery magic\n"));
                        return -1;
                }

                /* ensure the recovery marker has been removed on disk */
                if (transaction_sync(tdb, magic_offset, 4) == -1) {
                        return -1;
                }
        }

        tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0, 1);

        /*
          TODO: maybe write to some dummy hdr field, or write to magic
          offset without mmap, before the last sync, instead of the
          utime() call
        */

        /* on some systems (like Linux 2.6.x) changes via mmap/msync
           don't change the mtime of the file, this means the file may
           not be backed up (as tdb rounding to block sizes means that
           file size changes are quite rare too). The following forces
           mtime changes when a transaction completes */
#ifdef HAVE_UTIME
        utime(tdb->name, NULL);
#endif

        /* use a transaction cancel to free memory and remove the
           transaction locks */
        tdb_transaction_cancel(tdb);
        return 0;
}

int tdb_transaction_cancel

(

struct tdb_context *

tdb

)

transaction.c の 492 行で定義されています。

参照先 tdb_lock_type::count・tdb_transaction_el::data・tdb_transaction::elements・tdb_context::global_lock・tdb_transaction::hash_heads・tdb_header::hash_size・tdb_context::header・tdb_transaction::io_methods・tdb_lock_type::list・tdb_context::lockrecs・tdb_context::map_size・tdb_context::methods・tdb_transaction::nesting・tdb_transaction_el::next・tdb_context::num_lockrecs・tdb_context::num_locks・tdb_transaction::old_map_size・tdb・tdb_brlock()・TDB_DEBUG_ERROR・tdb_context::transaction・tdb_transaction::transaction_error.

参照元 addrec_db()・init_registry_data()・tdb_close()・tdb_trans_delete()・tdb_trans_store()・tdb_transaction_commit().

{       
        if (tdb->transaction == NULL) {
                TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_transaction_cancel: no transaction\n"));
                return -1;
        }

        if (tdb->transaction->nesting != 0) {
                tdb->transaction->transaction_error = 1;
                tdb->transaction->nesting--;
                return 0;
        }               

        tdb->map_size = tdb->transaction->old_map_size;

        /* free all the transaction elements */
        while (tdb->transaction->elements) {
                struct tdb_transaction_el *el = tdb->transaction->elements;
                tdb->transaction->elements = el->next;
                free(el->data);
                free(el);
        }

        /* remove any global lock created during the transaction */
        if (tdb->global_lock.count != 0) {
                tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 4*tdb->header.hash_size);
                tdb->global_lock.count = 0;
        }

        /* remove any locks created during the transaction */
        if (tdb->num_locks != 0) {
                int i;
                for (i=0;i<tdb->num_lockrecs;i++) {
                        tdb_brlock(tdb,FREELIST_TOP+4*tdb->lockrecs[i].list,
                                   F_UNLCK,F_SETLKW, 0, 1);
                }
                tdb->num_locks = 0;
                tdb->num_lockrecs = 0;
                SAFE_FREE(tdb->lockrecs);
        }

        /* restore the normal io methods */
        tdb->methods = tdb->transaction->io_methods;

        tdb_brlock(tdb, FREELIST_TOP, F_UNLCK, F_SETLKW, 0, 0);
        tdb_brlock(tdb, TRANSACTION_LOCK, F_UNLCK, F_SETLKW, 0, 1);
        SAFE_FREE(tdb->transaction->hash_heads);
        SAFE_FREE(tdb->transaction);
        
        return 0;
}

int tdb_transaction_recover

(

struct tdb_context *

tdb

)

transaction.c の 936 行で定義されています。

参照先 tdb_transaction_el::data・tdb_context::ecode・tdb_context::fd・len・list_struct::magic・tdb_context::map_size・tdb_context::methods・tdb_context::read_only・tdb・tdb_convert()・TDB_DEBUG_FATAL・TDB_DEBUG_TRACE・TDB_ERR_CORRUPT・TDB_ERR_IO・TDB_ERR_OOM・tdb_mmap()・tdb_munmap()・tdb_ofs_read()・tdb_ofs_write()・tdb_methods::tdb_read・tdb_methods::tdb_write・transaction_sync().

参照元 tdb_open_ex()・tdb_transaction_commit().

{
        tdb_off_t recovery_head, recovery_eof;
        unsigned char *data, *p;
        u32 zero = 0;
        struct list_struct rec;

        /* find the recovery area */
        if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to read recovery head\n"));
                tdb->ecode = TDB_ERR_IO;
                return -1;
        }

        if (recovery_head == 0) {
                /* we have never allocated a recovery record */
                return 0;
        }

        /* read the recovery record */
        if (tdb->methods->tdb_read(tdb, recovery_head, &rec, 
                                   sizeof(rec), DOCONV()) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to read recovery record\n"));           
                tdb->ecode = TDB_ERR_IO;
                return -1;
        }

        if (rec.magic != TDB_RECOVERY_MAGIC) {
                /* there is no valid recovery data */
                return 0;
        }

        if (tdb->read_only) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: attempt to recover read only database\n"));
                tdb->ecode = TDB_ERR_CORRUPT;
                return -1;
        }

        recovery_eof = rec.key_len;

        data = (unsigned char *)malloc(rec.data_len);
        if (data == NULL) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to allocate recovery data\n"));         
                tdb->ecode = TDB_ERR_OOM;
                return -1;
        }

        /* read the full recovery data */
        if (tdb->methods->tdb_read(tdb, recovery_head + sizeof(rec), data,
                                   rec.data_len, 0) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to read recovery data\n"));             
                tdb->ecode = TDB_ERR_IO;
                return -1;
        }

        /* recover the file data */
        p = data;
        while (p+8 < data + rec.data_len) {
                u32 ofs, len;
                if (DOCONV()) {
                        tdb_convert(p, 8);
                }
                memcpy(&ofs, p, 4);
                memcpy(&len, p+4, 4);

                if (tdb->methods->tdb_write(tdb, ofs, p+8, len) == -1) {
                        free(data);
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to recover %d bytes at offset %d\n", len, ofs));
                        tdb->ecode = TDB_ERR_IO;
                        return -1;
                }
                p += 8 + len;
        }

        free(data);

        if (transaction_sync(tdb, 0, tdb->map_size) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to sync recovery\n"));
                tdb->ecode = TDB_ERR_IO;
                return -1;
        }

        /* if the recovery area is after the recovered eof then remove it */
        if (recovery_eof <= recovery_head) {
                if (tdb_ofs_write(tdb, TDB_RECOVERY_HEAD, &zero) == -1) {
                        TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to remove recovery head\n"));
                        tdb->ecode = TDB_ERR_IO;
                        return -1;                      
                }
        }

        /* remove the recovery magic */
        if (tdb_ofs_write(tdb, recovery_head + offsetof(struct list_struct, magic), 
                          &zero) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to remove recovery magic\n"));
                tdb->ecode = TDB_ERR_IO;
                return -1;                      
        }
        
        /* reduce the file size to the old size */
        tdb_munmap(tdb);
        if (ftruncate(tdb->fd, recovery_eof) != 0) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to reduce to recovery size\n"));
                tdb->ecode = TDB_ERR_IO;
                return -1;                      
        }
        tdb->map_size = recovery_eof;
        tdb_mmap(tdb);

        if (transaction_sync(tdb, 0, recovery_eof) == -1) {
                TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_transaction_recover: failed to sync2 recovery\n"));
                tdb->ecode = TDB_ERR_IO;
                return -1;
        }

        TDB_LOG((tdb, TDB_DEBUG_TRACE, "tdb_transaction_recover: recovered %d byte database\n", 
                 recovery_eof));

        /* all done */
        return 0;
}

int tdb_get_seqnum

(

struct tdb_context *

tdb

)

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

参照先 tdb・tdb_ofs_read().

参照元 notify_init()・notify_load().

{
        tdb_off_t seqnum=0;

        tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
        return seqnum;
}

int tdb_hash_size

(

struct tdb_context *

tdb

)

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

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

参照元 backup_tdb().

{
        return tdb->header.hash_size;
}

size_t tdb_map_size

(

struct tdb_context *

tdb

)

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

参照先 tdb_context::map_size・tdb.

参照元 stat_cache_add().

{
        return tdb->map_size;
}

int tdb_get_flags

(

struct tdb_context *

tdb

)

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

参照先 tdb_context::flags・tdb.

参照元 idmap_tdb_convert().

{
        return tdb->flags;
}

int tdb_chainlock	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_lock().

参照元 addrec_db()・brl_get_locks_internal()・get_share_mode_lock()・idmap_tdb_remove_mapping()・idmap_tdb_set_mapping()・message_send_pid_internal()・py_tdb_hnd_chainlock()・retrieve_all_messages()・smb_lock_share_mode_entry()・tdb_chainlock_with_timeout_internal()・tdb_lock_bystring().

{
        return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
}

int tdb_chainunlock	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_unlock().

参照元 addrec_db()・byte_range_lock_destructor()・idmap_tdb_remove_mapping()・idmap_tdb_set_mapping()・message_send_pid_internal()・py_tdb_hnd_chainunlock()・remove_from_jobs_changed()・retrieve_all_messages()・share_mode_lock_destructor()・smb_unlock_share_mode_entry()・tdb_unlock_bystring().

{
        return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
}

int tdb_chainlock_read	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_lock().

参照元 tdb_chainlock_with_timeout_internal().

{
        return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
}

int tdb_chainunlock_read	(	struct tdb_context *	tdb,
		TDB_DATA	key
	)

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

参照先 tdb_context::hash_fn・tdb・tdb_unlock().

参照元 tdb_read_unlock_bystring().

{
        return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
}

void tdb_setalarm_sigptr	(	struct tdb_context *	tdb,
		volatile sig_atomic_t *	sigptr
	)

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

参照先 tdb_context::interrupt_sig_ptr・tdb.

参照元 tdb_chainlock_with_timeout_internal().

{
        tdb->interrupt_sig_ptr = ptr;
}

void tdb_dump_all

(

struct tdb_context *

tdb

)

dump.c の 84 行で定義されています。

参照先 tdb_header::hash_size・tdb_context::header・printf()・tdb・tdb_dump_chain().

参照元 do_command().

{
        int i;
        for (i=0;i<tdb->header.hash_size;i++) {
                tdb_dump_chain(tdb, i);
        }
        printf("freelist:\n");
        tdb_dump_chain(tdb, -1);
}

int tdb_printfreelist

(

struct tdb_context *

tdb

)

dump.c の 94 行で定義されています。

参照先 tdb_context::methods・printf()・tdb・tdb_lock()・tdb_ofs_read()・tdb_methods::tdb_read・tdb_unlock().

参照元 do_command().

{
        int ret;
        long total_free = 0;
        tdb_off_t offset, rec_ptr;
        struct list_struct rec;

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

        offset = FREELIST_TOP;

        /* read in the freelist top */
        if (tdb_ofs_read(tdb, offset, &rec_ptr) == -1) {
                tdb_unlock(tdb, -1, F_WRLCK);
                return 0;
        }

        printf("freelist top=[0x%08x]\n", rec_ptr );
        while (rec_ptr) {
                if (tdb->methods->tdb_read(tdb, rec_ptr, (char *)&rec, 
                                           sizeof(rec), DOCONV()) == -1) {
                        tdb_unlock(tdb, -1, F_WRLCK);
                        return -1;
                }

                if (rec.magic != TDB_FREE_MAGIC) {
                        printf("bad magic 0x%08x in free list\n", rec.magic);
                        tdb_unlock(tdb, -1, F_WRLCK);
                        return -1;
                }

                printf("entry offset=[0x%08x], rec.rec_len = [0x%08x (%d)] (end = 0x%08x)\n", 
                       rec_ptr, rec.rec_len, rec.rec_len, rec_ptr + rec.rec_len);
                total_free += rec.rec_len;

                /* move to the next record */
                rec_ptr = rec.next;
        }
        printf("total rec_len = [0x%08x (%d)]\n", (int)total_free, 
               (int)total_free);

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

int tdb_validate_freelist	(	struct tdb_context *	tdb,
		int *	pnum_entries
	)

freelistcheck.c の 47 行で定義されています。

参照先 tdb_header::hash_size・tdb_context::header・last_ptr・list_struct::next・rec_free_read()・seen_insert()・tdb・tdb_close()・TDB_ERR_CORRUPT・tdb_lock()・tdb_ofs_read()・tdb_open()・tdb_unlock().

参照元 main().

{
        struct tdb_context *mem_tdb = NULL;
        struct list_struct rec;
        tdb_off_t rec_ptr, last_ptr;
        int ret = -1;

        *pnum_entries = 0;

        mem_tdb = tdb_open("flval", tdb->header.hash_size,
                                TDB_INTERNAL, O_RDWR, 0600);
        if (!mem_tdb) {
                return -1;
        }

        if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
                tdb_close(mem_tdb);
                return 0;
        }

        last_ptr = FREELIST_TOP;

        /* Store the FREELIST_TOP record. */
        if (seen_insert(mem_tdb, last_ptr) == -1) {
                ret = TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
                goto fail;
        }

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

        while (rec_ptr) {

                /* If we can't store this record (we've seen it
                   before) then the free list has a loop and must
                   be corrupt. */

                if (seen_insert(mem_tdb, rec_ptr)) {
                        ret = TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
                        goto fail;
                }

                if (rec_free_read(tdb, rec_ptr, &rec) == -1) {
                        goto fail;
                }

                /* move to the next record */
                last_ptr = rec_ptr;
                rec_ptr = rec.next;
                *pnum_entries += 1;
        }

        ret = 0;

  fail:

        tdb_close(mem_tdb);
        tdb_unlock(tdb, -1, F_WRLCK);
        return ret;
}

---

変数

TDB_DATA tdb_null

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

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

---