2 Unix SMB/CIFS implementation.
4 trivial database library
6 Copyright (C) Andrew Tridgell 1999-2005
7 Copyright (C) Paul `Rusty' Russell 2000
8 Copyright (C) Jeremy Allison 2000-2003
10 ** NOTE! The following LGPL license applies to the tdb
11 ** library. This does NOT imply that all of Samba is released
14 This library is free software; you can redistribute it and/or
15 modify it under the terms of the GNU Lesser General Public
16 License as published by the Free Software Foundation; either
17 version 3 of the License, or (at your option) any later version.
19 This library is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 Lesser General Public License for more details.
24 You should have received a copy of the GNU Lesser General Public
25 License along with this library; if not, see <http://www.gnu.org/licenses/>.
28 #include "tdb_private.h"
30 /* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
31 static struct tdb_context
*tdbs
= NULL
;
33 /* We use two hashes to double-check they're using the right hash function. */
34 void tdb_header_hash(struct tdb_context
*tdb
,
35 uint32_t *magic1_hash
, uint32_t *magic2_hash
)
38 uint32_t tdb_magic
= TDB_MAGIC
;
40 hash_key
.dptr
= discard_const_p(unsigned char, TDB_MAGIC_FOOD
);
41 hash_key
.dsize
= sizeof(TDB_MAGIC_FOOD
);
42 *magic1_hash
= tdb
->hash_fn(&hash_key
);
44 hash_key
.dptr
= (unsigned char *)CONVERT(tdb_magic
);
45 hash_key
.dsize
= sizeof(tdb_magic
);
46 *magic2_hash
= tdb
->hash_fn(&hash_key
);
48 /* Make sure at least one hash is non-zero! */
49 if (*magic1_hash
== 0 && *magic2_hash
== 0)
53 /* initialise a new database with a specified hash size */
54 static int tdb_new_database(struct tdb_context
*tdb
, struct tdb_header
*header
,
57 struct tdb_header
*newdb
;
61 /* We make it up in memory, then write it out if not internal */
62 size
= sizeof(struct tdb_header
) + (hash_size
+1)*sizeof(tdb_off_t
);
63 if (!(newdb
= (struct tdb_header
*)calloc(size
, 1))) {
64 tdb
->ecode
= TDB_ERR_OOM
;
68 /* Fill in the header */
69 newdb
->version
= TDB_VERSION
;
70 newdb
->hash_size
= hash_size
;
72 tdb_header_hash(tdb
, &newdb
->magic1_hash
, &newdb
->magic2_hash
);
74 /* Make sure older tdbs (which don't check the magic hash fields)
75 * will refuse to open this TDB. */
76 if (tdb
->flags
& TDB_INCOMPATIBLE_HASH
)
77 newdb
->rwlocks
= TDB_HASH_RWLOCK_MAGIC
;
79 if (tdb
->flags
& TDB_INTERNAL
) {
81 tdb
->map_ptr
= (char *)newdb
;
82 memcpy(header
, newdb
, sizeof(*header
));
83 /* Convert the `ondisk' version if asked. */
87 if (lseek(tdb
->fd
, 0, SEEK_SET
) == -1)
90 if (ftruncate(tdb
->fd
, 0) == -1)
93 /* This creates an endian-converted header, as if read from disk */
95 memcpy(header
, newdb
, sizeof(*header
));
96 /* Don't endian-convert the magic food! */
97 memcpy(newdb
->magic_food
, TDB_MAGIC_FOOD
, strlen(TDB_MAGIC_FOOD
)+1);
99 if (!tdb_write_all(tdb
->fd
, newdb
, size
))
110 static int tdb_already_open(dev_t device
,
113 struct tdb_context
*i
;
115 for (i
= tdbs
; i
; i
= i
->next
) {
116 if (i
->device
== device
&& i
->inode
== ino
) {
124 /* open the database, creating it if necessary
126 The open_flags and mode are passed straight to the open call on the
127 database file. A flags value of O_WRONLY is invalid. The hash size
128 is advisory, use zero for a default value.
130 Return is NULL on error, in which case errno is also set. Don't
131 try to call tdb_error or tdb_errname, just do strerror(errno).
133 @param name may be NULL for internal databases. */
134 _PUBLIC_
struct tdb_context
*tdb_open(const char *name
, int hash_size
, int tdb_flags
,
135 int open_flags
, mode_t mode
)
137 return tdb_open_ex(name
, hash_size
, tdb_flags
, open_flags
, mode
, NULL
, NULL
);
140 /* a default logging function */
141 static void null_log_fn(struct tdb_context
*tdb
, enum tdb_debug_level level
, const char *fmt
, ...) PRINTF_ATTRIBUTE(3, 4);
142 static void null_log_fn(struct tdb_context
*tdb
, enum tdb_debug_level level
, const char *fmt
, ...)
146 static bool check_header_hash(struct tdb_context
*tdb
,
147 struct tdb_header
*header
,
148 bool default_hash
, uint32_t *m1
, uint32_t *m2
)
150 tdb_header_hash(tdb
, m1
, m2
);
151 if (header
->magic1_hash
== *m1
&&
152 header
->magic2_hash
== *m2
) {
156 /* If they explicitly set a hash, always respect it. */
160 /* Otherwise, try the other inbuilt hash. */
161 if (tdb
->hash_fn
== tdb_old_hash
)
162 tdb
->hash_fn
= tdb_jenkins_hash
;
164 tdb
->hash_fn
= tdb_old_hash
;
165 return check_header_hash(tdb
, header
, false, m1
, m2
);
168 _PUBLIC_
struct tdb_context
*tdb_open_ex(const char *name
, int hash_size
, int tdb_flags
,
169 int open_flags
, mode_t mode
,
170 const struct tdb_logging_context
*log_ctx
,
171 tdb_hash_func hash_fn
)
173 int orig_errno
= errno
;
174 struct tdb_header header
;
175 struct tdb_context
*tdb
;
177 int rev
= 0, locked
= 0;
181 const char *hash_alg
;
182 uint32_t magic1
, magic2
;
186 if (!(tdb
= (struct tdb_context
*)calloc(1, sizeof *tdb
))) {
193 if (tdb_flags
& TDB_INTERNAL
) {
194 tdb_flags
|= TDB_INCOMPATIBLE_HASH
;
203 tdb
->flags
= tdb_flags
;
204 tdb
->open_flags
= open_flags
;
208 tdb
->log
.log_fn
= null_log_fn
;
209 tdb
->log
.log_private
= NULL
;
212 if (name
== NULL
&& (tdb_flags
& TDB_INTERNAL
)) {
213 name
= "__TDB_INTERNAL__";
217 tdb
->name
= discard_const_p(char, "__NULL__");
218 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: called with name == NULL\n"));
224 /* now make a copy of the name, as the caller memory might go away */
225 if (!(tdb
->name
= (char *)strdup(name
))) {
227 * set the name as the given string, so that tdb_name() will
228 * work in case of an error.
230 tdb
->name
= discard_const_p(char, name
);
231 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: can't strdup(%s)\n",
239 tdb
->hash_fn
= hash_fn
;
240 hash_alg
= "the user defined";
242 /* This controls what we use when creating a tdb. */
243 if (tdb
->flags
& TDB_INCOMPATIBLE_HASH
) {
244 tdb
->hash_fn
= tdb_jenkins_hash
;
246 tdb
->hash_fn
= tdb_old_hash
;
248 hash_alg
= "either default";
251 /* cache the page size */
252 tdb
->page_size
= getpagesize();
253 if (tdb
->page_size
<= 0) {
254 tdb
->page_size
= 0x2000;
257 tdb
->max_dead_records
= (tdb_flags
& TDB_VOLATILE
) ? 5 : 0;
259 if ((open_flags
& O_ACCMODE
) == O_WRONLY
) {
260 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: can't open tdb %s write-only\n",
267 hash_size
= DEFAULT_HASH_SIZE
;
268 if ((open_flags
& O_ACCMODE
) == O_RDONLY
) {
270 /* read only databases don't do locking or clear if first */
271 tdb
->flags
|= TDB_NOLOCK
;
272 tdb
->flags
&= ~TDB_CLEAR_IF_FIRST
;
275 if ((tdb
->flags
& TDB_ALLOW_NESTING
) &&
276 (tdb
->flags
& TDB_DISALLOW_NESTING
)) {
277 tdb
->ecode
= TDB_ERR_NESTING
;
278 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
279 "allow_nesting and disallow_nesting are not allowed together!"));
284 if (getenv("TDB_NO_FSYNC")) {
285 tdb
->flags
|= TDB_NOSYNC
;
289 * TDB_ALLOW_NESTING is the default behavior.
290 * Note: this may change in future versions!
292 if (!(tdb
->flags
& TDB_DISALLOW_NESTING
)) {
293 tdb
->flags
|= TDB_ALLOW_NESTING
;
296 /* internal databases don't mmap or lock, and start off cleared */
297 if (tdb
->flags
& TDB_INTERNAL
) {
298 tdb
->flags
|= (TDB_NOLOCK
| TDB_NOMMAP
);
299 tdb
->flags
&= ~TDB_CLEAR_IF_FIRST
;
300 if (tdb_new_database(tdb
, &header
, hash_size
) != 0) {
301 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: tdb_new_database failed!"));
304 tdb
->hash_size
= hash_size
;
308 if ((tdb
->fd
= open(name
, open_flags
, mode
)) == -1) {
309 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "tdb_open_ex: could not open file %s: %s\n",
310 name
, strerror(errno
)));
311 goto fail
; /* errno set by open(2) */
314 /* on exec, don't inherit the fd */
315 v
= fcntl(tdb
->fd
, F_GETFD
, 0);
316 fcntl(tdb
->fd
, F_SETFD
, v
| FD_CLOEXEC
);
318 /* ensure there is only one process initialising at once */
319 if (tdb_nest_lock(tdb
, OPEN_LOCK
, F_WRLCK
, TDB_LOCK_WAIT
) == -1) {
320 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: failed to get open lock on %s: %s\n",
321 name
, strerror(errno
)));
322 goto fail
; /* errno set by tdb_brlock */
325 /* we need to zero database if we are the only one with it open */
326 if ((tdb_flags
& TDB_CLEAR_IF_FIRST
) &&
328 (locked
= (tdb_nest_lock(tdb
, ACTIVE_LOCK
, F_WRLCK
, TDB_LOCK_NOWAIT
|TDB_LOCK_PROBE
) == 0))) {
330 ret
= tdb_brlock(tdb
, F_WRLCK
, FREELIST_TOP
, 0,
333 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
334 "tdb_brlock failed for %s: %s\n",
335 name
, strerror(errno
)));
338 ret
= tdb_new_database(tdb
, &header
, hash_size
);
340 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
341 "tdb_new_database failed for %s: %s\n",
342 name
, strerror(errno
)));
346 ret
= tdb_brunlock(tdb
, F_WRLCK
, FREELIST_TOP
, 0);
348 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
349 "tdb_unlockall failed for %s: %s\n",
350 name
, strerror(errno
)));
353 ret
= lseek(tdb
->fd
, 0, SEEK_SET
);
355 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
356 "lseek failed for %s: %s\n",
357 name
, strerror(errno
)));
363 if (read(tdb
->fd
, &header
, sizeof(header
)) != sizeof(header
)
364 || strcmp(header
.magic_food
, TDB_MAGIC_FOOD
) != 0) {
365 if (!(open_flags
& O_CREAT
) ||
366 tdb_new_database(tdb
, &header
, hash_size
) == -1) {
368 errno
= EIO
; /* ie bad format or something */
372 rev
= (tdb
->flags
& TDB_CONVERT
);
373 } else if (header
.version
!= TDB_VERSION
374 && !(rev
= (header
.version
==TDB_BYTEREV(TDB_VERSION
)))) {
379 vp
= (unsigned char *)&header
.version
;
380 vertest
= (((uint32_t)vp
[0]) << 24) | (((uint32_t)vp
[1]) << 16) |
381 (((uint32_t)vp
[2]) << 8) | (uint32_t)vp
[3];
382 tdb
->flags
|= (vertest
==TDB_VERSION
) ? TDB_BIGENDIAN
: 0;
384 tdb
->flags
&= ~TDB_CONVERT
;
386 tdb
->flags
|= TDB_CONVERT
;
387 tdb_convert(&header
, sizeof(header
));
389 if (fstat(tdb
->fd
, &st
) == -1)
392 if (header
.rwlocks
!= 0 &&
393 header
.rwlocks
!= TDB_HASH_RWLOCK_MAGIC
) {
394 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: spinlocks no longer supported\n"));
398 tdb
->hash_size
= header
.hash_size
;
400 if ((header
.magic1_hash
== 0) && (header
.magic2_hash
== 0)) {
401 /* older TDB without magic hash references */
402 tdb
->hash_fn
= tdb_old_hash
;
403 } else if (!check_header_hash(tdb
, &header
, !hash_fn
,
405 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
406 "%s was not created with %s hash function we are using\n"
407 "magic1_hash[0x%08X %s 0x%08X] "
408 "magic2_hash[0x%08X %s 0x%08X]\n",
411 (header
.magic1_hash
== magic1
) ? "==" : "!=",
414 (header
.magic2_hash
== magic2
) ? "==" : "!=",
420 /* Is it already in the open list? If so, fail. */
421 if (tdb_already_open(st
.st_dev
, st
.st_ino
)) {
422 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: "
423 "%s (%d,%d) is already open in this process\n",
424 name
, (int)st
.st_dev
, (int)st
.st_ino
));
429 /* Beware truncation! */
430 tdb
->map_size
= st
.st_size
;
431 if (tdb
->map_size
!= st
.st_size
) {
432 /* Ensure ecode is set for log fn. */
433 tdb
->ecode
= TDB_ERR_IO
;
434 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
435 "len %llu too large!\n", (long long)st
.st_size
));
440 tdb
->device
= st
.st_dev
;
441 tdb
->inode
= st
.st_ino
;
444 if (tdb_nest_unlock(tdb
, ACTIVE_LOCK
, F_WRLCK
, false) == -1) {
445 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: "
446 "failed to release ACTIVE_LOCK on %s: %s\n",
447 name
, strerror(errno
)));
453 /* We always need to do this if the CLEAR_IF_FIRST flag is set, even if
454 we didn't get the initial exclusive lock as we need to let all other
455 users know we're using it. */
457 if (tdb_flags
& TDB_CLEAR_IF_FIRST
) {
458 /* leave this lock in place to indicate it's in use */
459 if (tdb_nest_lock(tdb
, ACTIVE_LOCK
, F_RDLCK
, TDB_LOCK_WAIT
) == -1) {
464 /* if needed, run recovery */
465 if (tdb_transaction_recover(tdb
) == -1) {
471 char tracefile
[strlen(name
) + 32];
473 snprintf(tracefile
, sizeof(tracefile
),
474 "%s.trace.%li", name
, (long)getpid());
475 tdb
->tracefd
= open(tracefile
, O_WRONLY
|O_CREAT
|O_EXCL
, 0600);
476 if (tdb
->tracefd
>= 0) {
477 tdb_enable_seqnum(tdb
);
478 tdb_trace_open(tdb
, "tdb_open", hash_size
, tdb_flags
,
481 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: failed to open trace file %s!\n", tracefile
));
486 /* Internal (memory-only) databases skip all the code above to
487 * do with disk files, and resume here by releasing their
488 * open lock and hooking into the active list. */
489 if (tdb_nest_unlock(tdb
, OPEN_LOCK
, F_WRLCK
, false) == -1) {
498 { int save_errno
= errno
;
507 if (tdb
->flags
& TDB_INTERNAL
)
508 SAFE_FREE(tdb
->map_ptr
);
513 if (close(tdb
->fd
) != 0)
514 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: failed to close tdb->fd on error!\n"));
515 SAFE_FREE(tdb
->lockrecs
);
516 SAFE_FREE(tdb
->name
);
524 * Set the maximum number of dead records per hash chain
527 _PUBLIC_
void tdb_set_max_dead(struct tdb_context
*tdb
, int max_dead
)
529 tdb
->max_dead_records
= max_dead
;
535 * @returns -1 for error; 0 for success.
537 _PUBLIC_
int tdb_close(struct tdb_context
*tdb
)
539 struct tdb_context
**i
;
542 if (tdb
->transaction
) {
543 tdb_transaction_cancel(tdb
);
545 tdb_trace(tdb
, "tdb_close");
548 if (tdb
->flags
& TDB_INTERNAL
)
549 SAFE_FREE(tdb
->map_ptr
);
553 SAFE_FREE(tdb
->name
);
555 ret
= close(tdb
->fd
);
558 SAFE_FREE(tdb
->lockrecs
);
560 /* Remove from contexts list */
561 for (i
= &tdbs
; *i
; i
= &(*i
)->next
) {
571 memset(tdb
, 0, sizeof(*tdb
));
577 /* register a loging function */
578 _PUBLIC_
void tdb_set_logging_function(struct tdb_context
*tdb
,
579 const struct tdb_logging_context
*log_ctx
)
584 _PUBLIC_
void *tdb_get_logging_private(struct tdb_context
*tdb
)
586 return tdb
->log
.log_private
;
589 static int tdb_reopen_internal(struct tdb_context
*tdb
, bool active_lock
)
591 #if !defined(LIBREPLACE_PREAD_NOT_REPLACED) || \
592 !defined(LIBREPLACE_PWRITE_NOT_REPLACED)
596 if (tdb
->flags
& TDB_INTERNAL
) {
597 return 0; /* Nothing to do. */
600 if (tdb_have_extra_locks(tdb
)) {
601 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_reopen: reopen not allowed with locks held\n"));
605 if (tdb
->transaction
!= 0) {
606 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_reopen: reopen not allowed inside a transaction\n"));
610 /* If we have real pread & pwrite, we can skip reopen. */
611 #if !defined(LIBREPLACE_PREAD_NOT_REPLACED) || \
612 !defined(LIBREPLACE_PWRITE_NOT_REPLACED)
613 if (tdb_munmap(tdb
) != 0) {
614 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: munmap failed (%s)\n", strerror(errno
)));
617 if (close(tdb
->fd
) != 0)
618 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: WARNING closing tdb->fd failed!\n"));
619 tdb
->fd
= open(tdb
->name
, tdb
->open_flags
& ~(O_CREAT
|O_TRUNC
), 0);
621 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: open failed (%s)\n", strerror(errno
)));
624 if (fstat(tdb
->fd
, &st
) != 0) {
625 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: fstat failed (%s)\n", strerror(errno
)));
628 if (st
.st_ino
!= tdb
->inode
|| st
.st_dev
!= tdb
->device
) {
629 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: file dev/inode has changed!\n"));
632 if (tdb_mmap(tdb
) != 0) {
635 #endif /* fake pread or pwrite */
637 /* We may still think we hold the active lock. */
638 tdb
->num_lockrecs
= 0;
639 SAFE_FREE(tdb
->lockrecs
);
640 tdb
->lockrecs_array_length
= 0;
642 if (active_lock
&& tdb_nest_lock(tdb
, ACTIVE_LOCK
, F_RDLCK
, TDB_LOCK_WAIT
) == -1) {
643 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: failed to obtain active lock\n"));
654 /* reopen a tdb - this can be used after a fork to ensure that we have an independent
655 seek pointer from our parent and to re-establish locks */
656 _PUBLIC_
int tdb_reopen(struct tdb_context
*tdb
)
658 return tdb_reopen_internal(tdb
, tdb
->flags
& TDB_CLEAR_IF_FIRST
);
661 /* reopen all tdb's */
662 _PUBLIC_
int tdb_reopen_all(int parent_longlived
)
664 struct tdb_context
*tdb
;
666 for (tdb
=tdbs
; tdb
; tdb
= tdb
->next
) {
667 bool active_lock
= (tdb
->flags
& TDB_CLEAR_IF_FIRST
);
670 * If the parent is longlived (ie. a
671 * parent daemon architecture), we know
672 * it will keep it's active lock on a
673 * tdb opened with CLEAR_IF_FIRST. Thus
674 * for child processes we don't have to
675 * add an active lock. This is essential
676 * to improve performance on systems that
677 * keep POSIX locks as a non-scalable data
678 * structure in the kernel.
680 if (parent_longlived
) {
681 /* Ensure no clear-if-first. */
685 if (tdb_reopen_internal(tdb
, active_lock
) != 0)