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
30 #include "tdb_private.h"
32 /* check for an out of bounds access - if it is out of bounds then
33 see if the database has been expanded by someone else and expand
35 note that "len" is the minimum length needed for the db
37 static int tdb_oob(struct tdb_context
*tdb
, tdb_off_t len
, int probe
)
40 if (len
<= tdb
->map_size
)
42 if (tdb
->flags
& TDB_INTERNAL
) {
44 /* Ensure ecode is set for log fn. */
45 tdb
->ecode
= TDB_ERR_IO
;
46 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_oob len %d beyond internal malloc size %d\n",
47 (int)len
, (int)tdb
->map_size
));
49 return TDB_ERRCODE(TDB_ERR_IO
, -1);
52 if (fstat(tdb
->fd
, &st
) == -1) {
53 return TDB_ERRCODE(TDB_ERR_IO
, -1);
56 if (st
.st_size
< (size_t)len
) {
58 /* Ensure ecode is set for log fn. */
59 tdb
->ecode
= TDB_ERR_IO
;
60 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_oob len %d beyond eof at %d\n",
61 (int)len
, (int)st
.st_size
));
63 return TDB_ERRCODE(TDB_ERR_IO
, -1);
66 /* Unmap, update size, remap */
67 if (tdb_munmap(tdb
) == -1)
68 return TDB_ERRCODE(TDB_ERR_IO
, -1);
69 tdb
->map_size
= st
.st_size
;
74 /* write a lump of data at a specified offset */
75 static int tdb_write(struct tdb_context
*tdb
, tdb_off_t off
,
76 const void *buf
, tdb_len_t len
)
82 if (tdb
->read_only
|| tdb
->traverse_read
) {
83 tdb
->ecode
= TDB_ERR_RDONLY
;
87 if (tdb
->methods
->tdb_oob(tdb
, off
+ len
, 0) != 0)
91 memcpy(off
+ (char *)tdb
->map_ptr
, buf
, len
);
93 ssize_t written
= pwrite(tdb
->fd
, buf
, len
, off
);
94 if ((written
!= (ssize_t
)len
) && (written
!= -1)) {
96 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_write: wrote only "
97 "%d of %d bytes at %d, trying once more\n",
100 written
= pwrite(tdb
->fd
, (void *)((char *)buf
+written
),
105 /* Ensure ecode is set for log fn. */
106 tdb
->ecode
= TDB_ERR_IO
;
107 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_write failed at %d "
108 "len=%d (%s)\n", off
, len
, strerror(errno
)));
109 return TDB_ERRCODE(TDB_ERR_IO
, -1);
110 } else if (written
!= (ssize_t
)len
) {
111 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "tdb_write: failed to "
112 "write %d bytes at %d in two attempts\n",
115 return TDB_ERRCODE(TDB_ERR_IO
, -1);
121 /* Endian conversion: we only ever deal with 4 byte quantities */
122 void *tdb_convert(void *buf
, u32 size
)
124 u32 i
, *p
= (u32
*)buf
;
125 for (i
= 0; i
< size
/ 4; i
++)
126 p
[i
] = TDB_BYTEREV(p
[i
]);
131 /* read a lump of data at a specified offset, maybe convert */
132 static int tdb_read(struct tdb_context
*tdb
, tdb_off_t off
, void *buf
,
133 tdb_len_t len
, int cv
)
135 if (tdb
->methods
->tdb_oob(tdb
, off
+ len
, 0) != 0) {
140 memcpy(buf
, off
+ (char *)tdb
->map_ptr
, len
);
142 ssize_t ret
= pread(tdb
->fd
, buf
, len
, off
);
143 if (ret
!= (ssize_t
)len
) {
144 /* Ensure ecode is set for log fn. */
145 tdb
->ecode
= TDB_ERR_IO
;
146 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_read failed at %d "
147 "len=%d ret=%d (%s) map_size=%d\n",
148 (int)off
, (int)len
, (int)ret
, strerror(errno
),
149 (int)tdb
->map_size
));
150 return TDB_ERRCODE(TDB_ERR_IO
, -1);
154 tdb_convert(buf
, len
);
162 do an unlocked scan of the hash table heads to find the next non-zero head. The value
163 will then be confirmed with the lock held
165 static void tdb_next_hash_chain(struct tdb_context
*tdb
, u32
*chain
)
169 for (;h
< tdb
->header
.hash_size
;h
++) {
170 if (0 != *(u32
*)(TDB_HASH_TOP(h
) + (unsigned char *)tdb
->map_ptr
)) {
176 for (;h
< tdb
->header
.hash_size
;h
++) {
177 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(h
), &off
) != 0 || off
!= 0) {
186 int tdb_munmap(struct tdb_context
*tdb
)
188 if (tdb
->flags
& TDB_INTERNAL
)
193 int ret
= munmap(tdb
->map_ptr
, tdb
->map_size
);
202 void tdb_mmap(struct tdb_context
*tdb
)
204 if (tdb
->flags
& TDB_INTERNAL
)
208 if (!(tdb
->flags
& TDB_NOMMAP
)) {
209 tdb
->map_ptr
= mmap(NULL
, tdb
->map_size
,
210 PROT_READ
|(tdb
->read_only
? 0:PROT_WRITE
),
211 MAP_SHARED
|MAP_FILE
, tdb
->fd
, 0);
214 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
217 if (tdb
->map_ptr
== MAP_FAILED
) {
219 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "tdb_mmap failed for size %d (%s)\n",
220 tdb
->map_size
, strerror(errno
)));
230 /* expand a file. we prefer to use ftruncate, as that is what posix
231 says to use for mmap expansion */
232 static int tdb_expand_file(struct tdb_context
*tdb
, tdb_off_t size
, tdb_off_t addition
)
236 if (tdb
->read_only
|| tdb
->traverse_read
) {
237 tdb
->ecode
= TDB_ERR_RDONLY
;
241 if (ftruncate(tdb
->fd
, size
+addition
) == -1) {
243 ssize_t written
= pwrite(tdb
->fd
, &b
, 1, (size
+addition
) - 1);
245 /* try once more, potentially revealing errno */
246 written
= pwrite(tdb
->fd
, &b
, 1, (size
+addition
) - 1);
249 /* again - give up, guessing errno */
253 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "expand_file to %d failed (%s)\n",
254 size
+addition
, strerror(errno
)));
259 /* now fill the file with something. This ensures that the
260 file isn't sparse, which would be very bad if we ran out of
261 disk. This must be done with write, not via mmap */
262 memset(buf
, TDB_PAD_BYTE
, sizeof(buf
));
264 size_t n
= addition
>sizeof(buf
)?sizeof(buf
):addition
;
265 ssize_t written
= pwrite(tdb
->fd
, buf
, n
, size
);
267 /* prevent infinite loops: try _once_ more */
268 written
= pwrite(tdb
->fd
, buf
, n
, size
);
271 /* give up, trying to provide a useful errno */
272 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "expand_file write "
273 "returned 0 twice: giving up!\n"));
276 } else if (written
== -1) {
277 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "expand_file write of "
278 "%d bytes failed (%s)\n", n
, strerror(errno
)));
280 } else if (written
!= n
) {
281 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "expand_file: wrote "
282 "only %d of %d bytes - retrying\n", written
,n
));
291 /* expand the database at least size bytes by expanding the underlying
292 file and doing the mmap again if necessary */
293 int tdb_expand(struct tdb_context
*tdb
, tdb_off_t size
)
295 struct list_struct rec
;
298 if (tdb_lock(tdb
, -1, F_WRLCK
) == -1) {
299 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "lock failed in tdb_expand\n"));
303 /* must know about any previous expansions by another process */
304 tdb
->methods
->tdb_oob(tdb
, tdb
->map_size
+ 1, 1);
306 /* always make room for at least 10 more records, and round
307 the database up to a multiple of the page size */
308 size
= TDB_ALIGN(tdb
->map_size
+ size
*10, tdb
->page_size
) - tdb
->map_size
;
310 if (!(tdb
->flags
& TDB_INTERNAL
))
314 * We must ensure the file is unmapped before doing this
315 * to ensure consistency with systems like OpenBSD where
316 * writes and mmaps are not consistent.
319 /* expand the file itself */
320 if (!(tdb
->flags
& TDB_INTERNAL
)) {
321 if (tdb
->methods
->tdb_expand_file(tdb
, tdb
->map_size
, size
) != 0)
325 tdb
->map_size
+= size
;
327 if (tdb
->flags
& TDB_INTERNAL
) {
328 char *new_map_ptr
= (char *)realloc(tdb
->map_ptr
,
331 tdb
->map_size
-= size
;
334 tdb
->map_ptr
= new_map_ptr
;
337 * We must ensure the file is remapped before adding the space
338 * to ensure consistency with systems like OpenBSD where
339 * writes and mmaps are not consistent.
342 /* We're ok if the mmap fails as we'll fallback to read/write */
346 /* form a new freelist record */
347 memset(&rec
,'\0',sizeof(rec
));
348 rec
.rec_len
= size
- sizeof(rec
);
350 /* link it into the free list */
351 offset
= tdb
->map_size
- size
;
352 if (tdb_free(tdb
, offset
, &rec
) == -1)
355 tdb_unlock(tdb
, -1, F_WRLCK
);
358 tdb_unlock(tdb
, -1, F_WRLCK
);
362 /* read/write a tdb_off_t */
363 int tdb_ofs_read(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_off_t
*d
)
365 return tdb
->methods
->tdb_read(tdb
, offset
, (char*)d
, sizeof(*d
), DOCONV());
368 int tdb_ofs_write(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_off_t
*d
)
371 return tdb
->methods
->tdb_write(tdb
, offset
, CONVERT(off
), sizeof(*d
));
375 /* read a lump of data, allocating the space for it */
376 char *tdb_alloc_read(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_len_t len
)
380 /* some systems don't like zero length malloc */
385 if (!(buf
= (char *)malloc(len
))) {
386 /* Ensure ecode is set for log fn. */
387 tdb
->ecode
= TDB_ERR_OOM
;
388 TDB_LOG((tdb
, TDB_DEBUG_ERROR
,"tdb_alloc_read malloc failed len=%d (%s)\n",
389 len
, strerror(errno
)));
390 return TDB_ERRCODE(TDB_ERR_OOM
, buf
);
392 if (tdb
->methods
->tdb_read(tdb
, offset
, buf
, len
, 0) == -1) {
399 /* Give a piece of tdb data to a parser */
401 int tdb_parse_data(struct tdb_context
*tdb
, TDB_DATA key
,
402 tdb_off_t offset
, tdb_len_t len
,
403 int (*parser
)(TDB_DATA key
, TDB_DATA data
,
412 if ((tdb
->transaction
== NULL
) && (tdb
->map_ptr
!= NULL
)) {
414 * Optimize by avoiding the malloc/memcpy/free, point the
415 * parser directly at the mmap area.
417 if (tdb
->methods
->tdb_oob(tdb
, offset
+len
, 0) != 0) {
420 data
.dptr
= offset
+ (char *)tdb
->map_ptr
;
421 return parser(key
, data
, private_data
);
424 if (!(data
.dptr
= tdb_alloc_read(tdb
, offset
, len
))) {
428 result
= parser(key
, data
, private_data
);
433 /* read/write a record */
434 int tdb_rec_read(struct tdb_context
*tdb
, tdb_off_t offset
, struct list_struct
*rec
)
436 if (tdb
->methods
->tdb_read(tdb
, offset
, rec
, sizeof(*rec
),DOCONV()) == -1)
438 if (TDB_BAD_MAGIC(rec
)) {
439 /* Ensure ecode is set for log fn. */
440 tdb
->ecode
= TDB_ERR_CORRUPT
;
441 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec
->magic
, offset
));
442 return TDB_ERRCODE(TDB_ERR_CORRUPT
, -1);
444 return tdb
->methods
->tdb_oob(tdb
, rec
->next
+sizeof(*rec
), 0);
447 int tdb_rec_write(struct tdb_context
*tdb
, tdb_off_t offset
, struct list_struct
*rec
)
449 struct list_struct r
= *rec
;
450 return tdb
->methods
->tdb_write(tdb
, offset
, CONVERT(r
), sizeof(r
));
453 static const struct tdb_methods io_methods
= {
463 initialise the default methods table
465 void tdb_io_init(struct tdb_context
*tdb
)
467 tdb
->methods
= &io_methods
;