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 #define MAX(a,b) ((a) > (b) ? (a) : (b))
33 /* check for an out of bounds access - if it is out of bounds then
34 see if the database has been expanded by someone else and expand
36 note that "len" is the minimum length needed for the db
38 static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, int probe)
41 if (len <= tdb->map_size)
43 if (tdb->flags & TDB_INTERNAL) {
45 /* Ensure ecode is set for log fn. */
46 tdb->ecode = TDB_ERR_IO;
47 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond internal malloc size %d\n",
48 (int)len, (int)tdb->map_size));
53 if (fstat(tdb->fd, &st) == -1) {
54 tdb->ecode = TDB_ERR_IO;
58 if (st.st_size < (size_t)len) {
60 /* Ensure ecode is set for log fn. */
61 tdb->ecode = TDB_ERR_IO;
62 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %d beyond eof at %d\n",
63 (int)len, (int)st.st_size));
68 /* Unmap, update size, remap */
69 if (tdb_munmap(tdb) == -1) {
70 tdb->ecode = TDB_ERR_IO;
73 tdb->map_size = st.st_size;
78 /* write a lump of data at a specified offset */
79 static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
80 const void *buf, tdb_len_t len)
86 if (tdb->read_only || tdb->traverse_read) {
87 tdb->ecode = TDB_ERR_RDONLY;
91 if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
95 memcpy(off + (char *)tdb->map_ptr, buf, len);
97 ssize_t written = pwrite(tdb->fd, buf, len, off);
98 if ((written != (ssize_t)len) && (written != -1)) {
100 tdb->ecode = TDB_ERR_IO;
101 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
102 "%d of %d bytes at %d, trying once more\n",
103 (int)written, len, off));
104 written = pwrite(tdb->fd, (const char *)buf+written,
109 /* Ensure ecode is set for log fn. */
110 tdb->ecode = TDB_ERR_IO;
111 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
112 "len=%d (%s)\n", off, len, strerror(errno)));
114 } else if (written != (ssize_t)len) {
115 tdb->ecode = TDB_ERR_IO;
116 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
117 "write %d bytes at %d in two attempts\n",
125 /* Endian conversion: we only ever deal with 4 byte quantities */
126 void *tdb_convert(void *buf, uint32_t size)
129 unsigned char *p = buf, tmp;
131 for (i = 0; i < size; i += 4) {
143 /* read a lump of data at a specified offset, maybe convert */
144 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
145 tdb_len_t len, int cv)
147 if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0) {
152 memcpy(buf, off + (char *)tdb->map_ptr, len);
154 ssize_t ret = pread(tdb->fd, buf, len, off);
155 if (ret != (ssize_t)len) {
156 /* Ensure ecode is set for log fn. */
157 tdb->ecode = TDB_ERR_IO;
158 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d "
159 "len=%d ret=%d (%s) map_size=%d\n",
160 (int)off, (int)len, (int)ret, strerror(errno),
161 (int)tdb->map_size));
166 tdb_convert(buf, len);
174 do an unlocked scan of the hash table heads to find the next non-zero head. The value
175 will then be confirmed with the lock held
177 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
181 for (;h < tdb->header.hash_size;h++) {
182 if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
188 for (;h < tdb->header.hash_size;h++) {
189 if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
198 int tdb_munmap(struct tdb_context *tdb)
200 if (tdb->flags & TDB_INTERNAL)
207 ret = munmap(tdb->map_ptr, tdb->map_size);
216 void tdb_mmap(struct tdb_context *tdb)
218 if (tdb->flags & TDB_INTERNAL)
222 if (!(tdb->flags & TDB_NOMMAP)) {
223 tdb->map_ptr = mmap(NULL, tdb->map_size,
224 PROT_READ|(tdb->read_only? 0:PROT_WRITE),
225 MAP_SHARED, tdb->fd, 0);
228 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
231 if (tdb->map_ptr == MAP_FAILED) {
233 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n",
234 tdb->map_size, strerror(errno)));
244 /* expand a file. we prefer to use ftruncate, as that is what posix
245 says to use for mmap expansion */
246 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
250 if (tdb->read_only || tdb->traverse_read) {
251 tdb->ecode = TDB_ERR_RDONLY;
255 if (ftruncate(tdb->fd, size+addition) == -1) {
257 ssize_t written = pwrite(tdb->fd, &b, 1, (size+addition) - 1);
259 /* try once more, potentially revealing errno */
260 written = pwrite(tdb->fd, &b, 1, (size+addition) - 1);
263 /* again - give up, guessing errno */
267 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n",
268 size+addition, strerror(errno)));
273 /* now fill the file with something. This ensures that the
274 file isn't sparse, which would be very bad if we ran out of
275 disk. This must be done with write, not via mmap */
276 memset(buf, TDB_PAD_BYTE, sizeof(buf));
278 size_t n = addition>sizeof(buf)?sizeof(buf):addition;
279 ssize_t written = pwrite(tdb->fd, buf, n, size);
281 /* prevent infinite loops: try _once_ more */
282 written = pwrite(tdb->fd, buf, n, size);
285 /* give up, trying to provide a useful errno */
286 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write "
287 "returned 0 twice: giving up!\n"));
290 } else if (written == -1) {
291 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of "
292 "%d bytes failed (%s)\n", (int)n,
295 } else if (written != n) {
296 TDB_LOG((tdb, TDB_DEBUG_WARNING, "expand_file: wrote "
297 "only %d of %d bytes - retrying\n", (int)written,
306 /* You need 'size', this tells you how much you should expand by. */
307 tdb_off_t tdb_expand_adjust(tdb_off_t map_size, tdb_off_t size, int page_size)
309 tdb_off_t new_size, top_size;
311 /* limit size in order to avoid using up huge amounts of memory for
312 * in memory tdbs if an oddball huge record creeps in */
313 if (size > 100 * 1024) {
314 top_size = map_size + size * 2;
316 top_size = map_size + size * 100;
319 /* always make room for at least top_size more records, and at
320 least 25% more space. if the DB is smaller than 100MiB,
321 otherwise grow it by 10% only. */
322 if (map_size > 100 * 1024 * 1024) {
323 new_size = map_size * 1.10;
325 new_size = map_size * 1.25;
328 /* Round the database up to a multiple of the page size */
329 new_size = MAX(top_size, new_size);
330 return TDB_ALIGN(new_size, page_size) - map_size;
333 /* expand the database at least size bytes by expanding the underlying
334 file and doing the mmap again if necessary */
335 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
337 struct tdb_record rec;
340 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
341 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
345 /* must know about any previous expansions by another process */
346 tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
348 size = tdb_expand_adjust(tdb->map_size, size, tdb->page_size);
350 if (!(tdb->flags & TDB_INTERNAL))
354 * We must ensure the file is unmapped before doing this
355 * to ensure consistency with systems like OpenBSD where
356 * writes and mmaps are not consistent.
359 /* expand the file itself */
360 if (!(tdb->flags & TDB_INTERNAL)) {
361 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
365 tdb->map_size += size;
367 if (tdb->flags & TDB_INTERNAL) {
368 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
371 tdb->map_size -= size;
374 tdb->map_ptr = new_map_ptr;
377 * We must ensure the file is remapped before adding the space
378 * to ensure consistency with systems like OpenBSD where
379 * writes and mmaps are not consistent.
382 /* We're ok if the mmap fails as we'll fallback to read/write */
386 /* form a new freelist record */
387 memset(&rec,'\0',sizeof(rec));
388 rec.rec_len = size - sizeof(rec);
390 /* link it into the free list */
391 offset = tdb->map_size - size;
392 if (tdb_free(tdb, offset, &rec) == -1)
395 tdb_unlock(tdb, -1, F_WRLCK);
398 tdb_unlock(tdb, -1, F_WRLCK);
402 /* read/write a tdb_off_t */
403 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
405 return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
408 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
411 return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
415 /* read a lump of data, allocating the space for it */
416 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
420 /* some systems don't like zero length malloc */
422 if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
423 /* Ensure ecode is set for log fn. */
424 tdb->ecode = TDB_ERR_OOM;
425 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
426 len, strerror(errno)));
429 if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
436 /* Give a piece of tdb data to a parser */
438 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
439 tdb_off_t offset, tdb_len_t len,
440 int (*parser)(TDB_DATA key, TDB_DATA data,
449 if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
451 * Optimize by avoiding the malloc/memcpy/free, point the
452 * parser directly at the mmap area.
454 if (tdb->methods->tdb_oob(tdb, offset+len, 0) != 0) {
457 data.dptr = offset + (unsigned char *)tdb->map_ptr;
458 return parser(key, data, private_data);
461 if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
465 result = parser(key, data, private_data);
470 /* read/write a record */
471 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
473 if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
475 if (TDB_BAD_MAGIC(rec)) {
476 /* Ensure ecode is set for log fn. */
477 tdb->ecode = TDB_ERR_CORRUPT;
478 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
481 return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
484 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
486 struct tdb_record r = *rec;
487 return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
490 static const struct tdb_methods io_methods = {
499 initialise the default methods table
501 void tdb_io_init(struct tdb_context *tdb)
503 tdb->methods = &io_methods;