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)
128 uint32_t i, *p = (uint32_t *)buf;
129 for (i = 0; i < size / 4; i++)
130 p[i] = TDB_BYTEREV(p[i]);
135 /* read a lump of data at a specified offset, maybe convert */
136 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
137 tdb_len_t len, int cv)
139 if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0) {
144 memcpy(buf, off + (char *)tdb->map_ptr, len);
146 ssize_t ret = pread(tdb->fd, buf, len, off);
147 if (ret != (ssize_t)len) {
148 /* Ensure ecode is set for log fn. */
149 tdb->ecode = TDB_ERR_IO;
150 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d "
151 "len=%d ret=%d (%s) map_size=%d\n",
152 (int)off, (int)len, (int)ret, strerror(errno),
153 (int)tdb->map_size));
158 tdb_convert(buf, len);
166 do an unlocked scan of the hash table heads to find the next non-zero head. The value
167 will then be confirmed with the lock held
169 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
173 for (;h < tdb->header.hash_size;h++) {
174 if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
180 for (;h < tdb->header.hash_size;h++) {
181 if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
190 int tdb_munmap(struct tdb_context *tdb)
192 if (tdb->flags & TDB_INTERNAL)
199 ret = munmap(tdb->map_ptr, tdb->map_size);
208 void tdb_mmap(struct tdb_context *tdb)
210 if (tdb->flags & TDB_INTERNAL)
214 if (!(tdb->flags & TDB_NOMMAP)) {
215 tdb->map_ptr = mmap(NULL, tdb->map_size,
216 PROT_READ|(tdb->read_only? 0:PROT_WRITE),
217 MAP_SHARED, tdb->fd, 0);
220 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
223 if (tdb->map_ptr == MAP_FAILED) {
225 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n",
226 tdb->map_size, strerror(errno)));
236 /* expand a file. we prefer to use ftruncate, as that is what posix
237 says to use for mmap expansion */
238 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
242 if (tdb->read_only || tdb->traverse_read) {
243 tdb->ecode = TDB_ERR_RDONLY;
247 if (ftruncate(tdb->fd, size+addition) == -1) {
249 ssize_t written = pwrite(tdb->fd, &b, 1, (size+addition) - 1);
251 /* try once more, potentially revealing errno */
252 written = pwrite(tdb->fd, &b, 1, (size+addition) - 1);
255 /* again - give up, guessing errno */
259 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n",
260 size+addition, strerror(errno)));
265 /* now fill the file with something. This ensures that the
266 file isn't sparse, which would be very bad if we ran out of
267 disk. This must be done with write, not via mmap */
268 memset(buf, TDB_PAD_BYTE, sizeof(buf));
270 size_t n = addition>sizeof(buf)?sizeof(buf):addition;
271 ssize_t written = pwrite(tdb->fd, buf, n, size);
273 /* prevent infinite loops: try _once_ more */
274 written = pwrite(tdb->fd, buf, n, size);
277 /* give up, trying to provide a useful errno */
278 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write "
279 "returned 0 twice: giving up!\n"));
282 } else if (written == -1) {
283 TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of "
284 "%d bytes failed (%s)\n", (int)n,
287 } else if (written != n) {
288 TDB_LOG((tdb, TDB_DEBUG_WARNING, "expand_file: wrote "
289 "only %d of %d bytes - retrying\n", (int)written,
299 /* expand the database at least size bytes by expanding the underlying
300 file and doing the mmap again if necessary */
301 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
303 struct tdb_record rec;
304 tdb_off_t offset, new_size;
306 if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
307 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
311 /* must know about any previous expansions by another process */
312 tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
314 /* always make room for at least 100 more records, and at
315 least 25% more space. Round the database up to a multiple
317 new_size = MAX(tdb->map_size + size*100, tdb->map_size * 1.25);
318 size = TDB_ALIGN(new_size, tdb->page_size) - tdb->map_size;
320 if (!(tdb->flags & TDB_INTERNAL))
324 * We must ensure the file is unmapped before doing this
325 * to ensure consistency with systems like OpenBSD where
326 * writes and mmaps are not consistent.
329 /* expand the file itself */
330 if (!(tdb->flags & TDB_INTERNAL)) {
331 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
335 tdb->map_size += size;
337 if (tdb->flags & TDB_INTERNAL) {
338 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
341 tdb->map_size -= size;
344 tdb->map_ptr = new_map_ptr;
347 * We must ensure the file is remapped before adding the space
348 * to ensure consistency with systems like OpenBSD where
349 * writes and mmaps are not consistent.
352 /* We're ok if the mmap fails as we'll fallback to read/write */
356 /* form a new freelist record */
357 memset(&rec,'\0',sizeof(rec));
358 rec.rec_len = size - sizeof(rec);
360 /* link it into the free list */
361 offset = tdb->map_size - size;
362 if (tdb_free(tdb, offset, &rec) == -1)
365 tdb_unlock(tdb, -1, F_WRLCK);
368 tdb_unlock(tdb, -1, F_WRLCK);
372 /* read/write a tdb_off_t */
373 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
375 return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
378 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
381 return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
385 /* read a lump of data, allocating the space for it */
386 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
390 /* some systems don't like zero length malloc */
392 if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
393 /* Ensure ecode is set for log fn. */
394 tdb->ecode = TDB_ERR_OOM;
395 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
396 len, strerror(errno)));
399 if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
406 /* Give a piece of tdb data to a parser */
408 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
409 tdb_off_t offset, tdb_len_t len,
410 int (*parser)(TDB_DATA key, TDB_DATA data,
419 if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
421 * Optimize by avoiding the malloc/memcpy/free, point the
422 * parser directly at the mmap area.
424 if (tdb->methods->tdb_oob(tdb, offset+len, 0) != 0) {
427 data.dptr = offset + (unsigned char *)tdb->map_ptr;
428 return parser(key, data, private_data);
431 if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
435 result = parser(key, data, private_data);
440 /* read/write a record */
441 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
443 if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
445 if (TDB_BAD_MAGIC(rec)) {
446 /* Ensure ecode is set for log fn. */
447 tdb->ecode = TDB_ERR_CORRUPT;
448 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
451 return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
454 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
456 struct tdb_record r = *rec;
457 return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
460 static const struct tdb_methods io_methods = {
469 initialise the default methods table
471 void tdb_io_init(struct tdb_context *tdb)
473 tdb->methods = &io_methods;