2 Unix SMB/CIFS implementation.
3 Samba database functions
4 Copyright (C) Andrew Tridgell 1999-2000
5 Copyright (C) Luke Kenneth Casson Leighton 2000
6 Copyright (C) Paul `Rusty' Russell 2000
7 Copyright (C) Jeremy Allison 2000
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
43 #define TDB_MAGIC_FOOD "TDB file\n"
44 #define TDB_VERSION (0x26011967 + 6)
45 #define TDB_MAGIC (0x26011999U)
46 #define TDB_FREE_MAGIC (~TDB_MAGIC)
47 #define TDB_DEAD_MAGIC (0xFEE1DEAD)
48 #define TDB_ALIGNMENT 4
49 #define MIN_REC_SIZE (2*sizeof(struct list_struct) + TDB_ALIGNMENT)
50 #define DEFAULT_HASH_SIZE 131
51 #define TDB_PAGE_SIZE 0x2000
52 #define FREELIST_TOP (sizeof(struct tdb_header))
53 #define TDB_ALIGN(x,a) (((x) + (a)-1) & ~((a)-1))
54 #define TDB_BYTEREV(x) (((((x)&0xff)<<24)|((x)&0xFF00)<<8)|(((x)>>8)&0xFF00)|((x)>>24))
55 #define TDB_DEAD(r) ((r)->magic == TDB_DEAD_MAGIC)
56 #define TDB_BAD_MAGIC(r) ((r)->magic != TDB_MAGIC && !TDB_DEAD(r))
57 #define TDB_HASH_TOP(hash) (FREELIST_TOP + (BUCKET(hash)+1)*sizeof(tdb_off))
59 /* NB assumes there is a local variable called "tdb" that is the
60 * current context, also takes doubly-parenthesized print-style
62 #define TDB_LOG(x) (tdb->log_fn?((tdb->log_fn x),0) : 0)
73 #define MAP_FAILED ((void *)-1)
76 /* free memory if the pointer is valid and zero the pointer */
78 #define SAFE_FREE(x) do { if ((x) != NULL) {free((x)); (x)=NULL;} } while(0)
81 #define BUCKET(hash) ((hash) % tdb->header.hash_size)
84 /* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
85 static TDB_CONTEXT *tdbs = NULL;
87 static int tdb_munmap(TDB_CONTEXT *tdb)
89 if (tdb->flags & TDB_INTERNAL)
94 int ret = munmap(tdb->map_ptr, tdb->map_size);
103 static void tdb_mmap(TDB_CONTEXT *tdb)
105 if (tdb->flags & TDB_INTERNAL)
109 if (!(tdb->flags & TDB_NOMMAP)) {
110 tdb->map_ptr = mmap(NULL, tdb->map_size,
111 PROT_READ|(tdb->read_only? 0:PROT_WRITE),
112 MAP_SHARED|MAP_FILE, tdb->fd, 0);
115 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
118 if (tdb->map_ptr == MAP_FAILED) {
120 TDB_LOG((tdb, 2, "tdb_mmap failed for size %d (%s)\n",
121 tdb->map_size, strerror(errno)));
131 /* Endian conversion: we only ever deal with 4 byte quantities */
132 static void *convert(void *buf, u32 size)
135 for (i = 0; i < size / 4; i++)
136 p[i] = TDB_BYTEREV(p[i]);
139 #define DOCONV() (tdb->flags & TDB_CONVERT)
140 #define CONVERT(x) (DOCONV() ? convert(&x, sizeof(x)) : &x)
142 /* the body of the database is made of one list_struct for the free space
143 plus a separate data list for each hash value */
145 tdb_off next; /* offset of the next record in the list */
146 tdb_len rec_len; /* total byte length of record */
147 tdb_len key_len; /* byte length of key */
148 tdb_len data_len; /* byte length of data */
149 u32 full_hash; /* the full 32 bit hash of the key */
150 u32 magic; /* try to catch errors */
151 /* the following union is implied:
153 char record[rec_len];
158 u32 totalsize; (tailer)
163 /* a byte range locking function - return 0 on success
164 this functions locks/unlocks 1 byte at the specified offset.
166 On error, errno is also set so that errors are passed back properly
167 through tdb_open(). */
168 static int tdb_brlock(TDB_CONTEXT *tdb, tdb_off offset,
169 int rw_type, int lck_type, int probe)
173 if (tdb->flags & TDB_NOLOCK)
175 if (tdb->read_only) {
181 fl.l_whence = SEEK_SET;
186 if (fcntl(tdb->fd,lck_type,&fl) == -1) {
188 TDB_LOG((tdb, 5,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d\n",
189 tdb->fd, offset, rw_type, lck_type));
191 /* errno set by fcntl */
192 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
197 /* lock a list in the database. list -1 is the alloc list */
198 static int tdb_lock(TDB_CONTEXT *tdb, int list, int ltype)
200 if (list < -1 || list >= (int)tdb->header.hash_size) {
201 TDB_LOG((tdb, 0,"tdb_lock: invalid list %d for ltype=%d\n",
205 if (tdb->flags & TDB_NOLOCK)
208 /* Since fcntl locks don't nest, we do a lock for the first one,
209 and simply bump the count for future ones */
210 if (tdb->locked[list+1].count == 0) {
211 if (!tdb->read_only && tdb->header.rwlocks) {
212 if (tdb_spinlock(tdb, list, ltype)) {
213 TDB_LOG((tdb, 0, "tdb_lock spinlock failed on list ltype=%d\n",
217 } else if (tdb_brlock(tdb,FREELIST_TOP+4*list,ltype,F_SETLKW, 0)) {
218 TDB_LOG((tdb, 0,"tdb_lock failed on list %d ltype=%d (%s)\n",
219 list, ltype, strerror(errno)));
222 tdb->locked[list+1].ltype = ltype;
224 tdb->locked[list+1].count++;
228 /* unlock the database: returns void because it's too late for errors. */
229 /* changed to return int it may be interesting to know there
230 has been an error --simo */
231 static int tdb_unlock(TDB_CONTEXT *tdb, int list, int ltype)
235 if (tdb->flags & TDB_NOLOCK)
239 if (list < -1 || list >= (int)tdb->header.hash_size) {
240 TDB_LOG((tdb, 0, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
244 if (tdb->locked[list+1].count==0) {
245 TDB_LOG((tdb, 0, "tdb_unlock: count is 0\n"));
249 if (tdb->locked[list+1].count == 1) {
250 /* Down to last nested lock: unlock underneath */
251 if (!tdb->read_only && tdb->header.rwlocks) {
252 ret = tdb_spinunlock(tdb, list, ltype);
254 ret = tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK, F_SETLKW, 0);
259 tdb->locked[list+1].count--;
262 TDB_LOG((tdb, 0,"tdb_unlock: An error occurred unlocking!\n"));
266 /* This is based on the hash algorithm from gdbm */
267 static u32 tdb_hash(TDB_DATA *key)
269 u32 value; /* Used to compute the hash value. */
270 u32 i; /* Used to cycle through random values. */
272 /* Set the initial value from the key size. */
273 for (value = 0x238F13AF * key->dsize, i=0; i < key->dsize; i++)
274 value = (value + (key->dptr[i] << (i*5 % 24)));
276 return (1103515243 * value + 12345);
279 /* check for an out of bounds access - if it is out of bounds then
280 see if the database has been expanded by someone else and expand
282 note that "len" is the minimum length needed for the db
284 static int tdb_oob(TDB_CONTEXT *tdb, tdb_off len, int probe)
287 if (len <= tdb->map_size)
289 if (tdb->flags & TDB_INTERNAL) {
291 TDB_LOG((tdb, 0,"tdb_oob len %d beyond internal malloc size %d\n",
292 (int)len, (int)tdb->map_size));
294 return TDB_ERRCODE(TDB_ERR_IO, -1);
297 if (fstat(tdb->fd, &st) == -1)
298 return TDB_ERRCODE(TDB_ERR_IO, -1);
300 if (st.st_size < (size_t)len) {
302 TDB_LOG((tdb, 0,"tdb_oob len %d beyond eof at %d\n",
303 (int)len, (int)st.st_size));
305 return TDB_ERRCODE(TDB_ERR_IO, -1);
308 /* Unmap, update size, remap */
310 tdb->map_size = st.st_size;
315 /* write a lump of data at a specified offset */
316 static int tdb_write(TDB_CONTEXT *tdb, tdb_off off, void *buf, tdb_len len)
318 if (tdb_oob(tdb, off + len, 0) != 0)
322 memcpy(off + (char *)tdb->map_ptr, buf, len);
324 else if (pwrite(tdb->fd, buf, len, off) != (ssize_t)len) {
326 else if (lseek(tdb->fd, off, SEEK_SET) != off
327 || write(tdb->fd, buf, len) != (ssize_t)len) {
329 TDB_LOG((tdb, 0,"tdb_write failed at %d len=%d (%s)\n",
330 off, len, strerror(errno)));
331 return TDB_ERRCODE(TDB_ERR_IO, -1);
336 /* read a lump of data at a specified offset, maybe convert */
337 static int tdb_read(TDB_CONTEXT *tdb,tdb_off off,void *buf,tdb_len len,int cv)
339 if (tdb_oob(tdb, off + len, 0) != 0)
343 memcpy(buf, off + (char *)tdb->map_ptr, len);
345 else if (pread(tdb->fd, buf, len, off) != (ssize_t)len) {
347 else if (lseek(tdb->fd, off, SEEK_SET) != off
348 || read(tdb->fd, buf, len) != (ssize_t)len) {
350 TDB_LOG((tdb, 0,"tdb_read failed at %d len=%d (%s)\n",
351 off, len, strerror(errno)));
352 return TDB_ERRCODE(TDB_ERR_IO, -1);
359 /* read a lump of data, allocating the space for it */
360 static char *tdb_alloc_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_len len)
364 if (!(buf = malloc(len))) {
365 TDB_LOG((tdb, 0,"tdb_alloc_read malloc failed len=%d (%s)\n",
366 len, strerror(errno)));
367 return TDB_ERRCODE(TDB_ERR_OOM, buf);
369 if (tdb_read(tdb, offset, buf, len, 0) == -1) {
376 /* read/write a tdb_off */
377 static int ofs_read(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
379 return tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
381 static int ofs_write(TDB_CONTEXT *tdb, tdb_off offset, tdb_off *d)
384 return tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
387 /* read/write a record */
388 static int rec_read(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
390 if (tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
392 if (TDB_BAD_MAGIC(rec)) {
393 TDB_LOG((tdb, 0,"rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
394 return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
396 return tdb_oob(tdb, rec->next+sizeof(*rec), 0);
398 static int rec_write(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
400 struct list_struct r = *rec;
401 return tdb_write(tdb, offset, CONVERT(r), sizeof(r));
404 /* read a freelist record and check for simple errors */
405 static int rec_free_read(TDB_CONTEXT *tdb, tdb_off off, struct list_struct *rec)
407 if (tdb_read(tdb, off, rec, sizeof(*rec),DOCONV()) == -1)
409 if (rec->magic != TDB_FREE_MAGIC) {
410 TDB_LOG((tdb, 0,"rec_free_read bad magic 0x%x at offset=%d\n",
412 return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
414 if (tdb_oob(tdb, rec->next+sizeof(*rec), 0) != 0)
419 /* update a record tailer (must hold allocation lock) */
420 static int update_tailer(TDB_CONTEXT *tdb, tdb_off offset,
421 const struct list_struct *rec)
425 /* Offset of tailer from record header */
426 totalsize = sizeof(*rec) + rec->rec_len;
427 return ofs_write(tdb, offset + totalsize - sizeof(tdb_off),
431 static tdb_off tdb_dump_record(TDB_CONTEXT *tdb, tdb_off offset)
433 struct list_struct rec;
434 tdb_off tailer_ofs, tailer;
436 if (tdb_read(tdb, offset, (char *)&rec, sizeof(rec), DOCONV()) == -1) {
437 printf("ERROR: failed to read record at %u\n", offset);
441 printf(" rec: offset=%u next=%d rec_len=%d key_len=%d data_len=%d full_hash=0x%x magic=0x%x\n",
442 offset, rec.next, rec.rec_len, rec.key_len, rec.data_len, rec.full_hash, rec.magic);
444 tailer_ofs = offset + sizeof(rec) + rec.rec_len - sizeof(tdb_off);
445 if (ofs_read(tdb, tailer_ofs, &tailer) == -1) {
446 printf("ERROR: failed to read tailer at %u\n", tailer_ofs);
450 if (tailer != rec.rec_len + sizeof(rec)) {
451 printf("ERROR: tailer does not match record! tailer=%u totalsize=%u\n",
452 (unsigned)tailer, (unsigned)(rec.rec_len + sizeof(rec)));
457 static int tdb_dump_chain(TDB_CONTEXT *tdb, int i)
459 tdb_off rec_ptr, top;
461 top = TDB_HASH_TOP(i);
463 if (tdb_lock(tdb, i, F_WRLCK) != 0)
466 if (ofs_read(tdb, top, &rec_ptr) == -1)
467 return tdb_unlock(tdb, i, F_WRLCK);
470 printf("hash=%d\n", i);
473 rec_ptr = tdb_dump_record(tdb, rec_ptr);
476 return tdb_unlock(tdb, i, F_WRLCK);
479 void tdb_dump_all(TDB_CONTEXT *tdb)
482 for (i=0;i<tdb->header.hash_size;i++) {
483 tdb_dump_chain(tdb, i);
485 printf("freelist:\n");
486 tdb_dump_chain(tdb, -1);
489 int tdb_printfreelist(TDB_CONTEXT *tdb)
493 tdb_off offset, rec_ptr;
494 struct list_struct rec;
496 if ((ret = tdb_lock(tdb, -1, F_WRLCK)) != 0)
499 offset = FREELIST_TOP;
501 /* read in the freelist top */
502 if (ofs_read(tdb, offset, &rec_ptr) == -1) {
506 printf("freelist top=[0x%08x]\n", rec_ptr );
508 if (tdb_read(tdb, rec_ptr, (char *)&rec, sizeof(rec), DOCONV()) == -1) {
512 if (rec.magic != TDB_FREE_MAGIC) {
513 printf("bad magic 0x%08x in free list\n", rec.magic);
517 printf("entry offset=[0x%08x], rec.rec_len = [0x%08x (%d)]\n", rec.next, rec.rec_len, rec.rec_len );
518 total_free += rec.rec_len;
520 /* move to the next record */
523 printf("total rec_len = [0x%08x (%d)]\n", (int)total_free,
526 return tdb_unlock(tdb, -1, F_WRLCK);
529 /* Remove an element from the freelist. Must have alloc lock. */
530 static int remove_from_freelist(TDB_CONTEXT *tdb, tdb_off off, tdb_off next)
534 /* read in the freelist top */
535 last_ptr = FREELIST_TOP;
536 while (ofs_read(tdb, last_ptr, &i) != -1 && i != 0) {
538 /* We've found it! */
539 return ofs_write(tdb, last_ptr, &next);
541 /* Follow chain (next offset is at start of record) */
544 TDB_LOG((tdb, 0,"remove_from_freelist: not on list at off=%d\n", off));
545 return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
548 /* Add an element into the freelist. Merge adjacent records if
550 static int tdb_free(TDB_CONTEXT *tdb, tdb_off offset, struct list_struct *rec)
554 /* Allocation and tailer lock */
555 if (tdb_lock(tdb, -1, F_WRLCK) != 0)
558 /* set an initial tailer, so if we fail we don't leave a bogus record */
559 if (update_tailer(tdb, offset, rec) != 0) {
560 TDB_LOG((tdb, 0, "tdb_free: upfate_tailer failed!\n"));
564 /* Look right first (I'm an Australian, dammit) */
565 right = offset + sizeof(*rec) + rec->rec_len;
566 if (right + sizeof(*rec) <= tdb->map_size) {
567 struct list_struct r;
569 if (tdb_read(tdb, right, &r, sizeof(r), DOCONV()) == -1) {
570 TDB_LOG((tdb, 0, "tdb_free: right read failed at %u\n", right));
574 /* If it's free, expand to include it. */
575 if (r.magic == TDB_FREE_MAGIC) {
576 if (remove_from_freelist(tdb, right, r.next) == -1) {
577 TDB_LOG((tdb, 0, "tdb_free: right free failed at %u\n", right));
580 rec->rec_len += sizeof(r) + r.rec_len;
586 left = offset - sizeof(tdb_off);
587 if (left > TDB_HASH_TOP(tdb->header.hash_size-1)) {
588 struct list_struct l;
591 /* Read in tailer and jump back to header */
592 if (ofs_read(tdb, left, &leftsize) == -1) {
593 TDB_LOG((tdb, 0, "tdb_free: left offset read failed at %u\n", left));
596 left = offset - leftsize;
598 /* Now read in record */
599 if (tdb_read(tdb, left, &l, sizeof(l), DOCONV()) == -1) {
600 TDB_LOG((tdb, 0, "tdb_free: left read failed at %u (%u)\n", left, leftsize));
604 /* If it's free, expand to include it. */
605 if (l.magic == TDB_FREE_MAGIC) {
606 if (remove_from_freelist(tdb, left, l.next) == -1) {
607 TDB_LOG((tdb, 0, "tdb_free: left free failed at %u\n", left));
611 rec->rec_len += leftsize;
617 if (update_tailer(tdb, offset, rec) == -1) {
618 TDB_LOG((tdb, 0, "tdb_free: update_tailer failed at %u\n", offset));
622 /* Now, prepend to free list */
623 rec->magic = TDB_FREE_MAGIC;
625 if (ofs_read(tdb, FREELIST_TOP, &rec->next) == -1 ||
626 rec_write(tdb, offset, rec) == -1 ||
627 ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
628 TDB_LOG((tdb, 0, "tdb_free record write failed at offset=%d\n", offset));
632 /* And we're done. */
633 tdb_unlock(tdb, -1, F_WRLCK);
637 tdb_unlock(tdb, -1, F_WRLCK);
642 /* expand a file. we prefer to use ftruncate, as that is what posix
643 says to use for mmap expansion */
644 static int expand_file(TDB_CONTEXT *tdb, tdb_off size, tdb_off addition)
647 #if HAVE_FTRUNCATE_EXTEND
648 if (ftruncate(tdb->fd, size+addition) != 0) {
649 TDB_LOG((tdb, 0, "expand_file ftruncate to %d failed (%s)\n",
650 size+addition, strerror(errno)));
657 if (pwrite(tdb->fd, &b, 1, (size+addition) - 1) != 1) {
659 if (lseek(tdb->fd, (size+addition) - 1, SEEK_SET) != (size+addition) - 1 ||
660 write(tdb->fd, &b, 1) != 1) {
662 TDB_LOG((tdb, 0, "expand_file to %d failed (%s)\n",
663 size+addition, strerror(errno)));
668 /* now fill the file with something. This ensures that the file isn't sparse, which would be
669 very bad if we ran out of disk. This must be done with write, not via mmap */
670 memset(buf, 0x42, sizeof(buf));
672 int n = addition>sizeof(buf)?sizeof(buf):addition;
674 int ret = pwrite(tdb->fd, buf, n, size);
677 if (lseek(tdb->fd, size, SEEK_SET) != size)
679 ret = write(tdb->fd, buf, n);
682 TDB_LOG((tdb, 0, "expand_file write of %d failed (%s)\n",
683 n, strerror(errno)));
693 /* expand the database at least size bytes by expanding the underlying
694 file and doing the mmap again if necessary */
695 static int tdb_expand(TDB_CONTEXT *tdb, tdb_off size)
697 struct list_struct rec;
700 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
701 TDB_LOG((tdb, 0, "lock failed in tdb_expand\n"));
705 /* must know about any previous expansions by another process */
706 tdb_oob(tdb, tdb->map_size + 1, 1);
708 /* always make room for at least 10 more records, and round
709 the database up to a multiple of TDB_PAGE_SIZE */
710 size = TDB_ALIGN(tdb->map_size + size*10, TDB_PAGE_SIZE) - tdb->map_size;
712 if (!(tdb->flags & TDB_INTERNAL))
716 * We must ensure the file is unmapped before doing this
717 * to ensure consistency with systems like OpenBSD where
718 * writes and mmaps are not consistent.
721 /* expand the file itself */
722 if (!(tdb->flags & TDB_INTERNAL)) {
723 if (expand_file(tdb, tdb->map_size, size) != 0)
727 tdb->map_size += size;
729 if (tdb->flags & TDB_INTERNAL)
730 tdb->map_ptr = realloc(tdb->map_ptr, tdb->map_size);
733 * We must ensure the file is remapped before adding the space
734 * to ensure consistency with systems like OpenBSD where
735 * writes and mmaps are not consistent.
738 /* We're ok if the mmap fails as we'll fallback to read/write */
742 /* form a new freelist record */
743 memset(&rec,'\0',sizeof(rec));
744 rec.rec_len = size - sizeof(rec);
746 /* link it into the free list */
747 offset = tdb->map_size - size;
748 if (tdb_free(tdb, offset, &rec) == -1)
751 tdb_unlock(tdb, -1, F_WRLCK);
754 tdb_unlock(tdb, -1, F_WRLCK);
758 /* allocate some space from the free list. The offset returned points
759 to a unconnected list_struct within the database with room for at
760 least length bytes of total data
762 0 is returned if the space could not be allocated
764 static tdb_off tdb_allocate(TDB_CONTEXT *tdb, tdb_len length,
765 struct list_struct *rec)
767 tdb_off rec_ptr, last_ptr, newrec_ptr;
768 struct list_struct newrec;
770 if (tdb_lock(tdb, -1, F_WRLCK) == -1)
773 /* Extra bytes required for tailer */
774 length += sizeof(tdb_off);
777 last_ptr = FREELIST_TOP;
779 /* read in the freelist top */
780 if (ofs_read(tdb, FREELIST_TOP, &rec_ptr) == -1)
783 /* keep looking until we find a freelist record big enough */
785 if (rec_free_read(tdb, rec_ptr, rec) == -1)
788 if (rec->rec_len >= length) {
789 /* found it - now possibly split it up */
790 if (rec->rec_len > length + MIN_REC_SIZE) {
791 /* Length of left piece */
792 length = TDB_ALIGN(length, TDB_ALIGNMENT);
794 /* Right piece to go on free list */
795 newrec.rec_len = rec->rec_len
796 - (sizeof(*rec) + length);
797 newrec_ptr = rec_ptr + sizeof(*rec) + length;
799 /* And left record is shortened */
800 rec->rec_len = length;
804 /* Remove allocated record from the free list */
805 if (ofs_write(tdb, last_ptr, &rec->next) == -1)
808 /* Update header: do this before we drop alloc
809 lock, otherwise tdb_free() might try to
810 merge with us, thinking we're free.
811 (Thanks Jeremy Allison). */
812 rec->magic = TDB_MAGIC;
813 if (rec_write(tdb, rec_ptr, rec) == -1)
816 /* Did we create new block? */
818 /* Update allocated record tailer (we
820 if (update_tailer(tdb, rec_ptr, rec) == -1)
823 /* Free new record */
824 if (tdb_free(tdb, newrec_ptr, &newrec) == -1)
828 /* all done - return the new record offset */
829 tdb_unlock(tdb, -1, F_WRLCK);
832 /* move to the next record */
836 /* we didn't find enough space. See if we can expand the
837 database and if we can then try again */
838 if (tdb_expand(tdb, length + sizeof(*rec)) == 0)
841 tdb_unlock(tdb, -1, F_WRLCK);
845 /* initialise a new database with a specified hash size */
846 static int tdb_new_database(TDB_CONTEXT *tdb, int hash_size)
848 struct tdb_header *newdb;
851 /* We make it up in memory, then write it out if not internal */
852 size = sizeof(struct tdb_header) + (hash_size+1)*sizeof(tdb_off);
853 if (!(newdb = calloc(size, 1)))
854 return TDB_ERRCODE(TDB_ERR_OOM, -1);
856 /* Fill in the header */
857 newdb->version = TDB_VERSION;
858 newdb->hash_size = hash_size;
860 newdb->rwlocks = size;
862 if (tdb->flags & TDB_INTERNAL) {
863 tdb->map_size = size;
864 tdb->map_ptr = (char *)newdb;
865 memcpy(&tdb->header, newdb, sizeof(tdb->header));
866 /* Convert the `ondisk' version if asked. */
870 if (lseek(tdb->fd, 0, SEEK_SET) == -1)
873 if (ftruncate(tdb->fd, 0) == -1)
876 /* This creates an endian-converted header, as if read from disk */
878 memcpy(&tdb->header, newdb, sizeof(tdb->header));
879 /* Don't endian-convert the magic food! */
880 memcpy(newdb->magic_food, TDB_MAGIC_FOOD, strlen(TDB_MAGIC_FOOD)+1);
881 if (write(tdb->fd, newdb, size) != size)
884 ret = tdb_create_rwlocks(tdb->fd, hash_size);
891 /* Returns 0 on fail. On success, return offset of record, and fills
893 static tdb_off tdb_find(TDB_CONTEXT *tdb, TDB_DATA key, u32 hash,
894 struct list_struct *r)
898 /* read in the hash top */
899 if (ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
902 /* keep looking until we find the right record */
904 if (rec_read(tdb, rec_ptr, r) == -1)
907 if (!TDB_DEAD(r) && hash==r->full_hash && key.dsize==r->key_len) {
909 /* a very likely hit - read the key */
910 k = tdb_alloc_read(tdb, rec_ptr + sizeof(*r),
915 if (memcmp(key.dptr, k, key.dsize) == 0) {
923 return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
926 /* If they do lockkeys, check that this hash is one they locked */
927 static int tdb_keylocked(TDB_CONTEXT *tdb, u32 hash)
930 if (!tdb->lockedkeys)
932 for (i = 0; i < tdb->lockedkeys[0]; i++)
933 if (tdb->lockedkeys[i+1] == hash)
935 return TDB_ERRCODE(TDB_ERR_NOLOCK, 0);
938 /* As tdb_find, but if you succeed, keep the lock */
939 static tdb_off tdb_find_lock(TDB_CONTEXT *tdb, TDB_DATA key, int locktype,
940 struct list_struct *rec)
944 hash = tdb_hash(&key);
945 if (!tdb_keylocked(tdb, hash))
947 if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
949 if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
950 tdb_unlock(tdb, BUCKET(hash), locktype);
954 enum TDB_ERROR tdb_error(TDB_CONTEXT *tdb)
959 static struct tdb_errname {
960 enum TDB_ERROR ecode; const char *estring;
961 } emap[] = { {TDB_SUCCESS, "Success"},
962 {TDB_ERR_CORRUPT, "Corrupt database"},
963 {TDB_ERR_IO, "IO Error"},
964 {TDB_ERR_LOCK, "Locking error"},
965 {TDB_ERR_OOM, "Out of memory"},
966 {TDB_ERR_EXISTS, "Record exists"},
967 {TDB_ERR_NOLOCK, "Lock exists on other keys"},
968 {TDB_ERR_NOEXIST, "Record does not exist"} };
970 /* Error string for the last tdb error */
971 const char *tdb_errorstr(TDB_CONTEXT *tdb)
974 for (i = 0; i < sizeof(emap) / sizeof(struct tdb_errname); i++)
975 if (tdb->ecode == emap[i].ecode)
976 return emap[i].estring;
977 return "Invalid error code";
980 /* update an entry in place - this only works if the new data size
981 is <= the old data size and the key exists.
984 static int tdb_update(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf)
986 struct list_struct rec;
991 if (!(rec_ptr = tdb_find_lock(tdb, key, F_WRLCK, &rec)))
994 /* must be long enough key, data and tailer */
995 if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off)) {
996 tdb->ecode = TDB_SUCCESS; /* Not really an error */
1000 if (tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
1001 dbuf.dptr, dbuf.dsize) == -1)
1004 if (dbuf.dsize != rec.data_len) {
1006 rec.data_len = dbuf.dsize;
1007 ret = rec_write(tdb, rec_ptr, &rec);
1011 tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK);
1015 /* find an entry in the database given a key */
1016 TDB_DATA tdb_fetch(TDB_CONTEXT *tdb, TDB_DATA key)
1019 struct list_struct rec;
1022 /* find which hash bucket it is in */
1023 if (!(rec_ptr = tdb_find_lock(tdb,key,F_RDLCK,&rec)))
1026 ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
1028 ret.dsize = rec.data_len;
1029 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
1033 /* check if an entry in the database exists
1035 note that 1 is returned if the key is found and 0 is returned if not found
1036 this doesn't match the conventions in the rest of this module, but is
1037 compatible with gdbm
1039 int tdb_exists(TDB_CONTEXT *tdb, TDB_DATA key)
1041 struct list_struct rec;
1043 if (tdb_find_lock(tdb, key, F_RDLCK, &rec) == 0)
1045 tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
1049 /* record lock stops delete underneath */
1050 static int lock_record(TDB_CONTEXT *tdb, tdb_off off)
1052 return off ? tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0) : 0;
1055 Write locks override our own fcntl readlocks, so check it here.
1056 Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
1057 an error to fail to get the lock here.
1060 static int write_lock_record(TDB_CONTEXT *tdb, tdb_off off)
1062 struct tdb_traverse_lock *i;
1063 for (i = &tdb->travlocks; i; i = i->next)
1066 return tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1);
1070 Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
1071 an error to fail to get the lock here.
1074 static int write_unlock_record(TDB_CONTEXT *tdb, tdb_off off)
1076 return tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0);
1078 /* fcntl locks don't stack: avoid unlocking someone else's */
1079 static int unlock_record(TDB_CONTEXT *tdb, tdb_off off)
1081 struct tdb_traverse_lock *i;
1086 for (i = &tdb->travlocks; i; i = i->next)
1089 return (count == 1 ? tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0) : 0);
1092 /* actually delete an entry in the database given the offset */
1093 static int do_delete(TDB_CONTEXT *tdb, tdb_off rec_ptr, struct list_struct*rec)
1095 tdb_off last_ptr, i;
1096 struct list_struct lastrec;
1098 if (tdb->read_only) return -1;
1100 if (write_lock_record(tdb, rec_ptr) == -1) {
1101 /* Someone traversing here: mark it as dead */
1102 rec->magic = TDB_DEAD_MAGIC;
1103 return rec_write(tdb, rec_ptr, rec);
1105 if (write_unlock_record(tdb, rec_ptr) != 0)
1108 /* find previous record in hash chain */
1109 if (ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
1111 for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
1112 if (rec_read(tdb, i, &lastrec) == -1)
1115 /* unlink it: next ptr is at start of record. */
1117 last_ptr = TDB_HASH_TOP(rec->full_hash);
1118 if (ofs_write(tdb, last_ptr, &rec->next) == -1)
1121 /* recover the space */
1122 if (tdb_free(tdb, rec_ptr, rec) == -1)
1127 /* Uses traverse lock: 0 = finish, -1 = error, other = record offset */
1128 static int tdb_next_lock(TDB_CONTEXT *tdb, struct tdb_traverse_lock *tlock,
1129 struct list_struct *rec)
1131 int want_next = (tlock->off != 0);
1133 /* No traversal allows if you've called tdb_lockkeys() */
1134 if (tdb->lockedkeys)
1135 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
1137 /* Lock each chain from the start one. */
1138 for (; tlock->hash < tdb->header.hash_size; tlock->hash++) {
1139 if (tdb_lock(tdb, tlock->hash, F_WRLCK) == -1)
1142 /* No previous record? Start at top of chain. */
1144 if (ofs_read(tdb, TDB_HASH_TOP(tlock->hash),
1148 /* Otherwise unlock the previous record. */
1149 if (unlock_record(tdb, tlock->off) != 0)
1154 /* We have offset of old record: grab next */
1155 if (rec_read(tdb, tlock->off, rec) == -1)
1157 tlock->off = rec->next;
1160 /* Iterate through chain */
1161 while( tlock->off) {
1163 if (rec_read(tdb, tlock->off, rec) == -1)
1165 if (!TDB_DEAD(rec)) {
1166 /* Woohoo: we found one! */
1167 if (lock_record(tdb, tlock->off) != 0)
1171 /* Try to clean dead ones from old traverses */
1172 current = tlock->off;
1173 tlock->off = rec->next;
1174 if (do_delete(tdb, current, rec) != 0)
1177 tdb_unlock(tdb, tlock->hash, F_WRLCK);
1180 /* We finished iteration without finding anything */
1181 return TDB_ERRCODE(TDB_SUCCESS, 0);
1185 if (tdb_unlock(tdb, tlock->hash, F_WRLCK) != 0)
1186 TDB_LOG((tdb, 0, "tdb_next_lock: On error unlock failed!\n"));
1190 /* traverse the entire database - calling fn(tdb, key, data) on each element.
1191 return -1 on error or the record count traversed
1192 if fn is NULL then it is not called
1193 a non-zero return value from fn() indicates that the traversal should stop
1195 int tdb_traverse(TDB_CONTEXT *tdb, tdb_traverse_func fn, void *state)
1198 struct list_struct rec;
1199 struct tdb_traverse_lock tl = { NULL, 0, 0 };
1202 /* This was in the initializaton, above, but the IRIX compiler
1203 * did not like it. crh
1205 tl.next = tdb->travlocks.next;
1207 /* fcntl locks don't stack: beware traverse inside traverse */
1208 tdb->travlocks.next = &tl;
1210 /* tdb_next_lock places locks on the record returned, and its chain */
1211 while ((ret = tdb_next_lock(tdb, &tl, &rec)) > 0) {
1213 /* now read the full record */
1214 key.dptr = tdb_alloc_read(tdb, tl.off + sizeof(rec),
1215 rec.key_len + rec.data_len);
1218 if (tdb_unlock(tdb, tl.hash, F_WRLCK) != 0)
1220 if (unlock_record(tdb, tl.off) != 0)
1221 TDB_LOG((tdb, 0, "tdb_traverse: key.dptr == NULL and unlock_record failed!\n"));
1224 key.dsize = rec.key_len;
1225 dbuf.dptr = key.dptr + rec.key_len;
1226 dbuf.dsize = rec.data_len;
1228 /* Drop chain lock, call out */
1229 if (tdb_unlock(tdb, tl.hash, F_WRLCK) != 0) {
1233 if (fn && fn(tdb, key, dbuf, state)) {
1234 /* They want us to terminate traversal */
1236 if (unlock_record(tdb, tl.off) != 0) {
1237 TDB_LOG((tdb, 0, "tdb_traverse: unlock_record failed!\n"));;
1240 tdb->travlocks.next = tl.next;
1241 SAFE_FREE(key.dptr);
1244 SAFE_FREE(key.dptr);
1247 tdb->travlocks.next = tl.next;
1254 /* find the first entry in the database and return its key */
1255 TDB_DATA tdb_firstkey(TDB_CONTEXT *tdb)
1258 struct list_struct rec;
1260 /* release any old lock */
1261 if (unlock_record(tdb, tdb->travlocks.off) != 0)
1263 tdb->travlocks.off = tdb->travlocks.hash = 0;
1265 if (tdb_next_lock(tdb, &tdb->travlocks, &rec) <= 0)
1267 /* now read the key */
1268 key.dsize = rec.key_len;
1269 key.dptr =tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),key.dsize);
1270 if (tdb_unlock(tdb, BUCKET(tdb->travlocks.hash), F_WRLCK) != 0)
1271 TDB_LOG((tdb, 0, "tdb_firstkey: error occurred while tdb_unlocking!\n"));
1275 /* find the next entry in the database, returning its key */
1276 TDB_DATA tdb_nextkey(TDB_CONTEXT *tdb, TDB_DATA oldkey)
1279 TDB_DATA key = tdb_null;
1280 struct list_struct rec;
1283 /* Is locked key the old key? If so, traverse will be reliable. */
1284 if (tdb->travlocks.off) {
1285 if (tdb_lock(tdb,tdb->travlocks.hash,F_WRLCK))
1287 if (rec_read(tdb, tdb->travlocks.off, &rec) == -1
1288 || !(k = tdb_alloc_read(tdb,tdb->travlocks.off+sizeof(rec),
1290 || memcmp(k, oldkey.dptr, oldkey.dsize) != 0) {
1291 /* No, it wasn't: unlock it and start from scratch */
1292 if (unlock_record(tdb, tdb->travlocks.off) != 0)
1294 if (tdb_unlock(tdb, tdb->travlocks.hash, F_WRLCK) != 0)
1296 tdb->travlocks.off = 0;
1302 if (!tdb->travlocks.off) {
1303 /* No previous element: do normal find, and lock record */
1304 tdb->travlocks.off = tdb_find_lock(tdb, oldkey, F_WRLCK, &rec);
1305 if (!tdb->travlocks.off)
1307 tdb->travlocks.hash = BUCKET(rec.full_hash);
1308 if (lock_record(tdb, tdb->travlocks.off) != 0) {
1309 TDB_LOG((tdb, 0, "tdb_nextkey: lock_record failed (%s)!\n", strerror(errno)));
1313 oldhash = tdb->travlocks.hash;
1315 /* Grab next record: locks chain and returned record,
1316 unlocks old record */
1317 if (tdb_next_lock(tdb, &tdb->travlocks, &rec) > 0) {
1318 key.dsize = rec.key_len;
1319 key.dptr = tdb_alloc_read(tdb, tdb->travlocks.off+sizeof(rec),
1321 /* Unlock the chain of this new record */
1322 if (tdb_unlock(tdb, tdb->travlocks.hash, F_WRLCK) != 0)
1323 TDB_LOG((tdb, 0, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
1325 /* Unlock the chain of old record */
1326 if (tdb_unlock(tdb, BUCKET(oldhash), F_WRLCK) != 0)
1327 TDB_LOG((tdb, 0, "tdb_nextkey: WARNING tdb_unlock failed!\n"));
1331 /* delete an entry in the database given a key */
1332 int tdb_delete(TDB_CONTEXT *tdb, TDB_DATA key)
1335 struct list_struct rec;
1338 if (!(rec_ptr = tdb_find_lock(tdb, key, F_WRLCK, &rec)))
1340 ret = do_delete(tdb, rec_ptr, &rec);
1341 if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
1342 TDB_LOG((tdb, 0, "tdb_delete: WARNING tdb_unlock failed!\n"));
1346 /* store an element in the database, replacing any existing element
1349 return 0 on success, -1 on failure
1351 int tdb_store(TDB_CONTEXT *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
1353 struct list_struct rec;
1359 /* find which hash bucket it is in */
1360 hash = tdb_hash(&key);
1361 if (!tdb_keylocked(tdb, hash))
1363 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
1366 /* check for it existing, on insert. */
1367 if (flag == TDB_INSERT) {
1368 if (tdb_exists(tdb, key)) {
1369 tdb->ecode = TDB_ERR_EXISTS;
1373 /* first try in-place update, on modify or replace. */
1374 if (tdb_update(tdb, key, dbuf) == 0)
1376 if (flag == TDB_MODIFY && tdb->ecode == TDB_ERR_NOEXIST)
1379 /* reset the error code potentially set by the tdb_update() */
1380 tdb->ecode = TDB_SUCCESS;
1382 /* delete any existing record - if it doesn't exist we don't
1383 care. Doing this first reduces fragmentation, and avoids
1384 coalescing with `allocated' block before it's updated. */
1385 if (flag != TDB_INSERT)
1386 tdb_delete(tdb, key);
1388 /* Copy key+value *before* allocating free space in case malloc
1389 fails and we are left with a dead spot in the tdb. */
1391 if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
1392 tdb->ecode = TDB_ERR_OOM;
1396 memcpy(p, key.dptr, key.dsize);
1397 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
1399 /* now we're into insert / modify / replace of a record which
1400 * we know could not be optimised by an in-place store (for
1401 * various reasons). */
1402 if (!(rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec)))
1405 /* Read hash top into next ptr */
1406 if (ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
1409 rec.key_len = key.dsize;
1410 rec.data_len = dbuf.dsize;
1411 rec.full_hash = hash;
1412 rec.magic = TDB_MAGIC;
1414 /* write out and point the top of the hash chain at it */
1415 if (rec_write(tdb, rec_ptr, &rec) == -1
1416 || tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
1417 || ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
1418 /* Need to tdb_unallocate() here */
1423 tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
1430 static int tdb_already_open(dev_t device,
1435 for (i = tdbs; i; i = i->next) {
1436 if (i->device == device && i->inode == ino) {
1444 /* open the database, creating it if necessary
1446 The open_flags and mode are passed straight to the open call on the
1447 database file. A flags value of O_WRONLY is invalid. The hash size
1448 is advisory, use zero for a default value.
1450 Return is NULL on error, in which case errno is also set. Don't
1451 try to call tdb_error or tdb_errname, just do strerror(errno).
1453 @param name may be NULL for internal databases. */
1454 TDB_CONTEXT *tdb_open(const char *name, int hash_size, int tdb_flags,
1455 int open_flags, mode_t mode)
1457 return tdb_open_ex(name, hash_size, tdb_flags, open_flags, mode, NULL);
1461 TDB_CONTEXT *tdb_open_ex(const char *name, int hash_size, int tdb_flags,
1462 int open_flags, mode_t mode,
1463 tdb_log_func log_fn)
1467 int rev = 0, locked;
1469 if (!(tdb = calloc(1, sizeof *tdb))) {
1470 /* Can't log this */
1476 tdb->map_ptr = NULL;
1477 tdb->lockedkeys = NULL;
1478 tdb->flags = tdb_flags;
1479 tdb->open_flags = open_flags;
1480 tdb->log_fn = log_fn;
1482 if ((open_flags & O_ACCMODE) == O_WRONLY) {
1483 TDB_LOG((tdb, 0, "tdb_open_ex: can't open tdb %s write-only\n",
1490 hash_size = DEFAULT_HASH_SIZE;
1491 if ((open_flags & O_ACCMODE) == O_RDONLY) {
1493 /* read only databases don't do locking or clear if first */
1494 tdb->flags |= TDB_NOLOCK;
1495 tdb->flags &= ~TDB_CLEAR_IF_FIRST;
1498 /* internal databases don't mmap or lock, and start off cleared */
1499 if (tdb->flags & TDB_INTERNAL) {
1500 tdb->flags |= (TDB_NOLOCK | TDB_NOMMAP);
1501 tdb->flags &= ~TDB_CLEAR_IF_FIRST;
1502 if (tdb_new_database(tdb, hash_size) != 0) {
1503 TDB_LOG((tdb, 0, "tdb_open_ex: tdb_new_database failed!"));
1509 if ((tdb->fd = open(name, open_flags, mode)) == -1) {
1510 TDB_LOG((tdb, 5, "tdb_open_ex: could not open file %s: %s\n",
1511 name, strerror(errno)));
1512 goto fail; /* errno set by open(2) */
1515 /* ensure there is only one process initialising at once */
1516 if (tdb_brlock(tdb, GLOBAL_LOCK, F_WRLCK, F_SETLKW, 0) == -1) {
1517 TDB_LOG((tdb, 0, "tdb_open_ex: failed to get global lock on %s: %s\n",
1518 name, strerror(errno)));
1519 goto fail; /* errno set by tdb_brlock */
1522 /* we need to zero database if we are the only one with it open */
1523 if ((locked = (tdb_brlock(tdb, ACTIVE_LOCK, F_WRLCK, F_SETLK, 0) == 0))
1524 && (tdb_flags & TDB_CLEAR_IF_FIRST)) {
1525 open_flags |= O_CREAT;
1526 if (ftruncate(tdb->fd, 0) == -1) {
1527 TDB_LOG((tdb, 0, "tdb_open_ex: "
1528 "failed to truncate %s: %s\n",
1529 name, strerror(errno)));
1530 goto fail; /* errno set by ftruncate */
1534 if (read(tdb->fd, &tdb->header, sizeof(tdb->header)) != sizeof(tdb->header)
1535 || strcmp(tdb->header.magic_food, TDB_MAGIC_FOOD) != 0
1536 || (tdb->header.version != TDB_VERSION
1537 && !(rev = (tdb->header.version==TDB_BYTEREV(TDB_VERSION))))) {
1538 /* its not a valid database - possibly initialise it */
1539 if (!(open_flags & O_CREAT) || tdb_new_database(tdb, hash_size) == -1) {
1540 errno = EIO; /* ie bad format or something */
1543 rev = (tdb->flags & TDB_CONVERT);
1546 tdb->flags &= ~TDB_CONVERT;
1548 tdb->flags |= TDB_CONVERT;
1549 convert(&tdb->header, sizeof(tdb->header));
1551 if (fstat(tdb->fd, &st) == -1)
1554 /* Is it already in the open list? If so, fail. */
1555 if (tdb_already_open(st.st_dev, st.st_ino)) {
1556 TDB_LOG((tdb, 2, "tdb_open_ex: "
1557 "%s (%d,%d) is already open in this process\n",
1558 name, st.st_dev, st.st_ino));
1563 if (!(tdb->name = (char *)strdup(name))) {
1568 tdb->map_size = st.st_size;
1569 tdb->device = st.st_dev;
1570 tdb->inode = st.st_ino;
1571 tdb->locked = calloc(tdb->header.hash_size+1, sizeof(tdb->locked[0]));
1573 TDB_LOG((tdb, 2, "tdb_open_ex: "
1574 "failed to allocate lock structure for %s\n",
1581 if (!tdb->read_only)
1582 if (tdb_clear_spinlocks(tdb) != 0) {
1583 TDB_LOG((tdb, 0, "tdb_open_ex: "
1584 "failed to clear spinlock\n"));
1587 if (tdb_brlock(tdb, ACTIVE_LOCK, F_UNLCK, F_SETLK, 0) == -1) {
1588 TDB_LOG((tdb, 0, "tdb_open_ex: "
1589 "failed to take ACTIVE_LOCK on %s: %s\n",
1590 name, strerror(errno)));
1594 /* leave this lock in place to indicate it's in use */
1595 if (tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0) == -1)
1599 /* Internal (memory-only) databases skip all the code above to
1600 * do with disk files, and resume here by releasing their
1601 * global lock and hooking into the active list. */
1602 if (tdb_brlock(tdb, GLOBAL_LOCK, F_UNLCK, F_SETLKW, 0) == -1)
1609 { int save_errno = errno;
1615 if (tdb->flags & TDB_INTERNAL)
1616 SAFE_FREE(tdb->map_ptr);
1620 SAFE_FREE(tdb->name);
1622 if (close(tdb->fd) != 0)
1623 TDB_LOG((tdb, 5, "tdb_open_ex: failed to close tdb->fd on error!\n"));
1624 SAFE_FREE(tdb->locked);
1631 /* close a database */
1632 int tdb_close(TDB_CONTEXT *tdb)
1638 if (tdb->flags & TDB_INTERNAL)
1639 SAFE_FREE(tdb->map_ptr);
1643 SAFE_FREE(tdb->name);
1645 ret = close(tdb->fd);
1646 SAFE_FREE(tdb->locked);
1647 SAFE_FREE(tdb->lockedkeys);
1649 /* Remove from contexts list */
1650 for (i = &tdbs; *i; i = &(*i)->next) {
1657 memset(tdb, 0, sizeof(*tdb));
1663 /* lock/unlock entire database */
1664 int tdb_lockall(TDB_CONTEXT *tdb)
1668 /* There are no locks on read-only dbs */
1670 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
1671 if (tdb->lockedkeys)
1672 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
1673 for (i = 0; i < tdb->header.hash_size; i++)
1674 if (tdb_lock(tdb, i, F_WRLCK))
1677 /* If error, release locks we have... */
1678 if (i < tdb->header.hash_size) {
1681 for ( j = 0; j < i; j++)
1682 tdb_unlock(tdb, j, F_WRLCK);
1683 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
1688 void tdb_unlockall(TDB_CONTEXT *tdb)
1691 for (i=0; i < tdb->header.hash_size; i++)
1692 tdb_unlock(tdb, i, F_WRLCK);
1695 int tdb_lockkeys(TDB_CONTEXT *tdb, u32 number, TDB_DATA keys[])
1699 /* Can't lock more keys if already locked */
1700 if (tdb->lockedkeys)
1701 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
1702 if (!(tdb->lockedkeys = malloc(sizeof(u32) * (number+1))))
1703 return TDB_ERRCODE(TDB_ERR_OOM, -1);
1704 /* First number in array is # keys */
1705 tdb->lockedkeys[0] = number;
1707 /* Insertion sort by bucket */
1708 for (i = 0; i < number; i++) {
1709 hash = tdb_hash(&keys[i]);
1710 for (j = 0; j < i && BUCKET(tdb->lockedkeys[j+1]) < BUCKET(hash); j++);
1711 memmove(&tdb->lockedkeys[j+2], &tdb->lockedkeys[j+1], sizeof(u32) * (i-j));
1712 tdb->lockedkeys[j+1] = hash;
1714 /* Finally, lock in order */
1715 for (i = 0; i < number; i++)
1716 if (tdb_lock(tdb, i, F_WRLCK))
1719 /* If error, release locks we have... */
1721 for ( j = 0; j < i; j++)
1722 tdb_unlock(tdb, j, F_WRLCK);
1723 SAFE_FREE(tdb->lockedkeys);
1724 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
1729 /* Unlock the keys previously locked by tdb_lockkeys() */
1730 void tdb_unlockkeys(TDB_CONTEXT *tdb)
1733 for (i = 0; i < tdb->lockedkeys[0]; i++)
1734 tdb_unlock(tdb, tdb->lockedkeys[i+1], F_WRLCK);
1735 SAFE_FREE(tdb->lockedkeys);
1738 /* lock/unlock one hash chain. This is meant to be used to reduce
1739 contention - it cannot guarantee how many records will be locked */
1740 int tdb_chainlock(TDB_CONTEXT *tdb, TDB_DATA key)
1742 return tdb_lock(tdb, BUCKET(tdb_hash(&key)), F_WRLCK);
1745 int tdb_chainunlock(TDB_CONTEXT *tdb, TDB_DATA key)
1747 return tdb_unlock(tdb, BUCKET(tdb_hash(&key)), F_WRLCK);
1751 /* register a loging function */
1752 void tdb_logging_function(TDB_CONTEXT *tdb, void (*fn)(TDB_CONTEXT *, int , const char *, ...))
1758 /* reopen a tdb - this is used after a fork to ensure that we have an independent
1759 seek pointer from our parent and to re-establish locks */
1760 int tdb_reopen(TDB_CONTEXT *tdb)
1764 if (tdb_munmap(tdb) != 0) {
1765 TDB_LOG((tdb, 0, "tdb_reopen: munmap failed (%s)\n", strerror(errno)));
1768 if (close(tdb->fd) != 0)
1769 TDB_LOG((tdb, 0, "tdb_reopen: WARNING closing tdb->fd failed!\n"));
1770 tdb->fd = open(tdb->name, tdb->open_flags & ~(O_CREAT|O_TRUNC), 0);
1771 if (tdb->fd == -1) {
1772 TDB_LOG((tdb, 0, "tdb_reopen: open failed (%s)\n", strerror(errno)));
1775 if (fstat(tdb->fd, &st) != 0) {
1776 TDB_LOG((tdb, 0, "tdb_reopen: fstat failed (%s)\n", strerror(errno)));
1779 if (st.st_ino != tdb->inode || st.st_dev != tdb->device) {
1780 TDB_LOG((tdb, 0, "tdb_reopen: file dev/inode has changed!\n"));
1784 if (tdb_brlock(tdb, ACTIVE_LOCK, F_RDLCK, F_SETLKW, 0) == -1) {
1785 TDB_LOG((tdb, 0, "tdb_reopen: failed to obtain active lock\n"));
1796 /* reopen all tdb's */
1797 int tdb_reopen_all(void)
1801 for (tdb=tdbs; tdb; tdb = tdb->next) {
1802 if (tdb_reopen(tdb) != 0) return -1;