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 2 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, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include "tdb_private.h"
31 /* all contexts, to ensure no double-opens (fcntl locks don't nest!) */
32 static struct tdb_context
*tdbs
= NULL
;
35 /* This is based on the hash algorithm from gdbm */
36 static unsigned int default_tdb_hash(TDB_DATA
*key
)
38 u32 value
; /* Used to compute the hash value. */
39 u32 i
; /* Used to cycle through random values. */
41 /* Set the initial value from the key size. */
42 for (value
= 0x238F13AF * key
->dsize
, i
=0; i
< key
->dsize
; i
++)
43 value
= (value
+ (key
->dptr
[i
] << (i
*5 % 24)));
45 return (1103515243 * value
+ 12345);
49 /* initialise a new database with a specified hash size */
50 static int tdb_new_database(struct tdb_context
*tdb
, int hash_size
)
52 struct tdb_header
*newdb
;
57 /* We make it up in memory, then write it out if not internal */
58 size
= sizeof(struct tdb_header
) + (hash_size
+1)*sizeof(tdb_off_t
);
59 if (!(newdb
= (struct tdb_header
*)calloc(size
, 1)))
60 return TDB_ERRCODE(TDB_ERR_OOM
, -1);
62 /* Fill in the header */
63 newdb
->version
= TDB_VERSION
;
64 newdb
->hash_size
= hash_size
;
65 if (tdb
->flags
& TDB_INTERNAL
) {
67 tdb
->map_ptr
= (char *)newdb
;
68 memcpy(&tdb
->header
, newdb
, sizeof(tdb
->header
));
69 /* Convert the `ondisk' version if asked. */
73 if (lseek(tdb
->fd
, 0, SEEK_SET
) == -1)
76 if (ftruncate(tdb
->fd
, 0) == -1)
79 /* This creates an endian-converted header, as if read from disk */
81 memcpy(&tdb
->header
, newdb
, sizeof(tdb
->header
));
82 /* Don't endian-convert the magic food! */
83 memcpy(newdb
->magic_food
, TDB_MAGIC_FOOD
, strlen(TDB_MAGIC_FOOD
)+1);
84 /* we still have "ret == -1" here */
85 written
= write(tdb
->fd
, newdb
, size
);
86 if (written
== size
) {
88 } else if (written
!= -1) {
89 /* call write once again, this usually should return -1 and
90 * set errno appropriately */
92 written
= write(tdb
->fd
, newdb
+written
, size
);
93 if (written
== size
) {
95 } else if (written
>= 0) {
96 /* a second incomplete write - we give up.
97 * guessing the errno... */
109 static int tdb_already_open(dev_t device
,
112 struct tdb_context
*i
;
114 for (i
= tdbs
; i
; i
= i
->next
) {
115 if (i
->device
== device
&& i
->inode
== ino
) {
123 /* open the database, creating it if necessary
125 The open_flags and mode are passed straight to the open call on the
126 database file. A flags value of O_WRONLY is invalid. The hash size
127 is advisory, use zero for a default value.
129 Return is NULL on error, in which case errno is also set. Don't
130 try to call tdb_error or tdb_errname, just do strerror(errno).
132 @param name may be NULL for internal databases. */
133 struct tdb_context
*tdb_open(const char *name
, int hash_size
, int tdb_flags
,
134 int open_flags
, mode_t mode
)
136 return tdb_open_ex(name
, hash_size
, tdb_flags
, open_flags
, mode
, NULL
, NULL
);
139 /* a default logging function */
140 static void null_log_fn(struct tdb_context
*tdb
, enum tdb_debug_level level
, const char *fmt
, ...) PRINTF_ATTRIBUTE(3, 4);
141 static void null_log_fn(struct tdb_context
*tdb
, enum tdb_debug_level level
, const char *fmt
, ...)
146 struct tdb_context
*tdb_open_ex(const char *name
, int hash_size
, int tdb_flags
,
147 int open_flags
, mode_t mode
,
148 const struct tdb_logging_context
*log_ctx
,
149 tdb_hash_func hash_fn
)
151 struct tdb_context
*tdb
;
153 int rev
= 0, locked
= 0;
157 if (!(tdb
= (struct tdb_context
*)calloc(1, sizeof *tdb
))) {
166 tdb
->flags
= tdb_flags
;
167 tdb
->open_flags
= open_flags
;
171 tdb
->log
.log_fn
= null_log_fn
;
172 tdb
->log
.log_private
= NULL
;
174 tdb
->hash_fn
= hash_fn
? hash_fn
: default_tdb_hash
;
176 /* cache the page size */
177 tdb
->page_size
= getpagesize();
178 if (tdb
->page_size
<= 0) {
179 tdb
->page_size
= 0x2000;
182 if ((open_flags
& O_ACCMODE
) == O_WRONLY
) {
183 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: can't open tdb %s write-only\n",
190 hash_size
= DEFAULT_HASH_SIZE
;
191 if ((open_flags
& O_ACCMODE
) == O_RDONLY
) {
193 /* read only databases don't do locking or clear if first */
194 tdb
->flags
|= TDB_NOLOCK
;
195 tdb
->flags
&= ~TDB_CLEAR_IF_FIRST
;
198 /* internal databases don't mmap or lock, and start off cleared */
199 if (tdb
->flags
& TDB_INTERNAL
) {
200 tdb
->flags
|= (TDB_NOLOCK
| TDB_NOMMAP
);
201 tdb
->flags
&= ~TDB_CLEAR_IF_FIRST
;
202 if (tdb_new_database(tdb
, hash_size
) != 0) {
203 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: tdb_new_database failed!"));
209 if ((tdb
->fd
= open(name
, open_flags
, mode
)) == -1) {
210 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "tdb_open_ex: could not open file %s: %s\n",
211 name
, strerror(errno
)));
212 goto fail
; /* errno set by open(2) */
215 /* ensure there is only one process initialising at once */
216 if (tdb
->methods
->tdb_brlock(tdb
, GLOBAL_LOCK
, F_WRLCK
, F_SETLKW
, 0, 1) == -1) {
217 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: failed to get global lock on %s: %s\n",
218 name
, strerror(errno
)));
219 goto fail
; /* errno set by tdb_brlock */
222 /* we need to zero database if we are the only one with it open */
223 if ((tdb_flags
& TDB_CLEAR_IF_FIRST
) &&
224 (locked
= (tdb
->methods
->tdb_brlock(tdb
, ACTIVE_LOCK
, F_WRLCK
, F_SETLK
, 0, 1) == 0))) {
225 open_flags
|= O_CREAT
;
226 if (ftruncate(tdb
->fd
, 0) == -1) {
227 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_open_ex: "
228 "failed to truncate %s: %s\n",
229 name
, strerror(errno
)));
230 goto fail
; /* errno set by ftruncate */
235 if (read(tdb
->fd
, &tdb
->header
, sizeof(tdb
->header
)) != sizeof(tdb
->header
)
236 || strcmp(tdb
->header
.magic_food
, TDB_MAGIC_FOOD
) != 0
237 || (tdb
->header
.version
!= TDB_VERSION
238 && !(rev
= (tdb
->header
.version
==TDB_BYTEREV(TDB_VERSION
))))) {
239 /* its not a valid database - possibly initialise it */
240 if (!(open_flags
& O_CREAT
) || tdb_new_database(tdb
, hash_size
) == -1) {
242 errno
= EIO
; /* ie bad format or something */
246 rev
= (tdb
->flags
& TDB_CONVERT
);
248 vp
= (unsigned char *)&tdb
->header
.version
;
249 vertest
= (((u32
)vp
[0]) << 24) | (((u32
)vp
[1]) << 16) |
250 (((u32
)vp
[2]) << 8) | (u32
)vp
[3];
251 tdb
->flags
|= (vertest
==TDB_VERSION
) ? TDB_BIGENDIAN
: 0;
253 tdb
->flags
&= ~TDB_CONVERT
;
255 tdb
->flags
|= TDB_CONVERT
;
256 tdb_convert(&tdb
->header
, sizeof(tdb
->header
));
258 if (fstat(tdb
->fd
, &st
) == -1)
261 if (tdb
->header
.rwlocks
!= 0) {
262 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: spinlocks no longer supported\n"));
266 /* Is it already in the open list? If so, fail. */
267 if (tdb_already_open(st
.st_dev
, st
.st_ino
)) {
268 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: "
269 "%s (%d,%d) is already open in this process\n",
270 name
, (int)st
.st_dev
, (int)st
.st_ino
));
275 if (!(tdb
->name
= (char *)strdup(name
))) {
280 tdb
->map_size
= st
.st_size
;
281 tdb
->device
= st
.st_dev
;
282 tdb
->inode
= st
.st_ino
;
283 tdb
->max_dead_records
= 0;
286 if (tdb
->methods
->tdb_brlock(tdb
, ACTIVE_LOCK
, F_UNLCK
, F_SETLK
, 0, 1) == -1) {
287 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: "
288 "failed to take ACTIVE_LOCK on %s: %s\n",
289 name
, strerror(errno
)));
295 /* We always need to do this if the CLEAR_IF_FIRST flag is set, even if
296 we didn't get the initial exclusive lock as we need to let all other
297 users know we're using it. */
299 if (tdb_flags
& TDB_CLEAR_IF_FIRST
) {
300 /* leave this lock in place to indicate it's in use */
301 if (tdb
->methods
->tdb_brlock(tdb
, ACTIVE_LOCK
, F_RDLCK
, F_SETLKW
, 0, 1) == -1)
305 /* if needed, run recovery */
306 if (tdb_transaction_recover(tdb
) == -1) {
311 /* Internal (memory-only) databases skip all the code above to
312 * do with disk files, and resume here by releasing their
313 * global lock and hooking into the active list. */
314 if (tdb
->methods
->tdb_brlock(tdb
, GLOBAL_LOCK
, F_UNLCK
, F_SETLKW
, 0, 1) == -1)
321 { int save_errno
= errno
;
327 if (tdb
->flags
& TDB_INTERNAL
)
328 SAFE_FREE(tdb
->map_ptr
);
332 SAFE_FREE(tdb
->name
);
334 if (close(tdb
->fd
) != 0)
335 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_open_ex: failed to close tdb->fd on error!\n"));
343 * Set the maximum number of dead records per hash chain
346 void tdb_set_max_dead(struct tdb_context
*tdb
, int max_dead
)
348 tdb
->max_dead_records
= max_dead
;
354 * @returns -1 for error; 0 for success.
356 int tdb_close(struct tdb_context
*tdb
)
358 struct tdb_context
**i
;
361 if (tdb
->transaction
) {
362 tdb_transaction_cancel(tdb
);
366 if (tdb
->flags
& TDB_INTERNAL
)
367 SAFE_FREE(tdb
->map_ptr
);
371 SAFE_FREE(tdb
->name
);
373 ret
= close(tdb
->fd
);
374 SAFE_FREE(tdb
->lockrecs
);
376 /* Remove from contexts list */
377 for (i
= &tdbs
; *i
; i
= &(*i
)->next
) {
384 memset(tdb
, 0, sizeof(*tdb
));
390 /* register a loging function */
391 void tdb_set_logging_function(struct tdb_context
*tdb
,
392 const struct tdb_logging_context
*log_ctx
)
397 void *tdb_get_logging_private(struct tdb_context
*tdb
)
399 return tdb
->log
.log_private
;
402 /* reopen a tdb - this can be used after a fork to ensure that we have an independent
403 seek pointer from our parent and to re-establish locks */
404 int tdb_reopen(struct tdb_context
*tdb
)
408 if (tdb
->flags
& TDB_INTERNAL
) {
409 return 0; /* Nothing to do. */
412 if (tdb
->num_locks
!= 0 || tdb
->global_lock
.count
) {
413 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_reopen: reopen not allowed with locks held\n"));
417 if (tdb
->transaction
!= 0) {
418 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "tdb_reopen: reopen not allowed inside a transaction\n"));
422 if (tdb_munmap(tdb
) != 0) {
423 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: munmap failed (%s)\n", strerror(errno
)));
426 if (close(tdb
->fd
) != 0)
427 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: WARNING closing tdb->fd failed!\n"));
428 tdb
->fd
= open(tdb
->name
, tdb
->open_flags
& ~(O_CREAT
|O_TRUNC
), 0);
430 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: open failed (%s)\n", strerror(errno
)));
433 if ((tdb
->flags
& TDB_CLEAR_IF_FIRST
) &&
434 (tdb
->methods
->tdb_brlock(tdb
, ACTIVE_LOCK
, F_RDLCK
, F_SETLKW
, 0, 1) == -1)) {
435 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: failed to obtain active lock\n"));
438 if (fstat(tdb
->fd
, &st
) != 0) {
439 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: fstat failed (%s)\n", strerror(errno
)));
442 if (st
.st_ino
!= tdb
->inode
|| st
.st_dev
!= tdb
->device
) {
443 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_reopen: file dev/inode has changed!\n"));
455 /* reopen all tdb's */
456 int tdb_reopen_all(int parent_longlived
)
458 struct tdb_context
*tdb
;
460 for (tdb
=tdbs
; tdb
; tdb
= tdb
->next
) {
462 * If the parent is longlived (ie. a
463 * parent daemon architecture), we know
464 * it will keep it's active lock on a
465 * tdb opened with CLEAR_IF_FIRST. Thus
466 * for child processes we don't have to
467 * add an active lock. This is essential
468 * to improve performance on systems that
469 * keep POSIX locks as a non-scalable data
470 * structure in the kernel.
472 if (parent_longlived
) {
473 /* Ensure no clear-if-first. */
474 tdb
->flags
&= ~TDB_CLEAR_IF_FIRST
;
477 if (tdb_reopen(tdb
) != 0)