return;
}
- if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
+ if (tdb_nest_lock(tdb, TDB_SEQNUM_OFS, F_WRLCK,
+ TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
return;
}
tdb_increment_seqnum_nonblock(tdb);
- tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
+ tdb_nest_unlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, false);
}
static int tdb_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
/* Returns 0 on fail. On success, return offset of record, and fills
in rec */
static tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
- struct list_struct *r)
+ struct tdb_record *r)
{
tdb_off_t rec_ptr;
}
/* detect tight infinite loop */
if (rec_ptr == r->next) {
+ tdb->ecode = TDB_ERR_CORRUPT;
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_find: loop detected.\n"));
- return TDB_ERRCODE(TDB_ERR_CORRUPT, 0);
+ return 0;
}
rec_ptr = r->next;
}
- return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
+ tdb->ecode = TDB_ERR_NOEXIST;
+ return 0;
}
/* As tdb_find, but if you succeed, keep the lock */
tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
- struct list_struct *rec)
+ struct tdb_record *rec)
{
uint32_t rec_ptr;
return rec_ptr;
}
+static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key);
/* update an entry in place - this only works if the new data size
is <= the old data size and the key exists.
*/
static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
{
- struct list_struct rec;
+ struct tdb_record rec;
tdb_off_t rec_ptr;
/* find entry */
if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
return -1;
+ /* it could be an exact duplicate of what is there - this is
+ * surprisingly common (eg. with a ldb re-index). */
+ if (rec.key_len == key.dsize &&
+ rec.data_len == dbuf.dsize &&
+ rec.full_hash == hash) {
+ TDB_DATA data = _tdb_fetch(tdb, key);
+ if (data.dsize == dbuf.dsize &&
+ memcmp(data.dptr, dbuf.dptr, data.dsize) == 0) {
+ if (data.dptr) {
+ free(data.dptr);
+ }
+ return 0;
+ }
+ if (data.dptr) {
+ free(data.dptr);
+ }
+ }
+
+
/* must be long enough key, data and tailer */
if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
tdb->ecode = TDB_SUCCESS; /* Not really an error */
static TDB_DATA _tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
+ struct tdb_record rec;
TDB_DATA ret;
uint32_t hash;
* function. The parsing function is executed under the chain read lock, so it
* should be fast and should not block on other syscalls.
*
- * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
+ * DON'T CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
*
* For mmapped tdb's that do not have a transaction open it points the parsing
* function directly at the mmap area, it avoids the malloc/memcpy in this
void *private_data)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
+ struct tdb_record rec;
int ret;
uint32_t hash;
if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, -1);
- return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
+ tdb->ecode = TDB_ERR_NOEXIST;
+ return 0;
}
tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
*/
static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
- struct list_struct rec;
+ struct tdb_record rec;
if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
return 0;
}
/* actually delete an entry in the database given the offset */
-int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
+int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct tdb_record *rec)
{
tdb_off_t last_ptr, i;
- struct list_struct lastrec;
+ struct tdb_record lastrec;
if (tdb->read_only || tdb->traverse_read) return -1;
{
int res = 0;
tdb_off_t rec_ptr;
- struct list_struct rec;
+ struct tdb_record rec;
/* read in the hash top */
if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
{
int res = -1;
- struct list_struct rec;
+ struct tdb_record rec;
tdb_off_t rec_ptr;
if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
{
tdb_off_t rec_ptr;
- struct list_struct rec;
+ struct tdb_record rec;
int ret;
if (tdb->max_dead_records != 0) {
* See if we have a dead record around with enough space
*/
static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
- struct list_struct *r, tdb_len_t length)
+ struct tdb_record *r, tdb_len_t length)
{
tdb_off_t rec_ptr;
static int _tdb_store(struct tdb_context *tdb, TDB_DATA key,
TDB_DATA dbuf, int flag, uint32_t hash)
{
- struct list_struct rec;
+ struct tdb_record rec;
tdb_off_t rec_ptr;
char *p = NULL;
int ret = -1;
void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
{
+ if ((flags & TDB_ALLOW_NESTING) &&
+ (flags & TDB_DISALLOW_NESTING)) {
+ tdb->ecode = TDB_ERR_NESTING;
+ TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_add_flags: "
+ "allow_nesting and disallow_nesting are not allowed together!"));
+ return;
+ }
+
+ if (flags & TDB_ALLOW_NESTING) {
+ tdb->flags &= ~TDB_DISALLOW_NESTING;
+ }
+ if (flags & TDB_DISALLOW_NESTING) {
+ tdb->flags &= ~TDB_ALLOW_NESTING;
+ }
+
tdb->flags |= flags;
}
void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
{
+ if ((flags & TDB_ALLOW_NESTING) &&
+ (flags & TDB_DISALLOW_NESTING)) {
+ tdb->ecode = TDB_ERR_NESTING;
+ TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_remove_flags: "
+ "allow_nesting and disallow_nesting are not allowed together!"));
+ return;
+ }
+
+ if (flags & TDB_ALLOW_NESTING) {
+ tdb->flags |= TDB_DISALLOW_NESTING;
+ }
+ if (flags & TDB_DISALLOW_NESTING) {
+ tdb->flags |= TDB_ALLOW_NESTING;
+ }
+
tdb->flags &= ~flags;
}
*/
static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
{
- struct list_struct rec;
+ struct tdb_record rec;
if (length <= sizeof(rec)) {
/* the region is not worth adding */
return 0;
/*
wipe the entire database, deleting all records. This can be done
- very fast by using a global lock. The entire data portion of the
+ very fast by using a allrecord lock. The entire data portion of the
file becomes a single entry in the freelist.
This code carefully steps around the recovery area, leaving it alone
}
if (recovery_head != 0) {
- struct list_struct rec;
+ struct tdb_record rec;
if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
return -1;
git.samba.org / ira / wip.git / blobdiff