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
);
92 } else if (pwrite(tdb
->fd
, buf
, len
, off
) != (ssize_t
)len
) {
93 /* Ensure ecode is set for log fn. */
94 tdb
->ecode
= TDB_ERR_IO
;
95 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_write failed at %d len=%d (%s)\n",
96 off
, len
, strerror(errno
)));
97 return TDB_ERRCODE(TDB_ERR_IO
, -1);
102 /* Endian conversion: we only ever deal with 4 byte quantities */
103 void *tdb_convert(void *buf
, uint32_t size
)
105 uint32_t i
, *p
= (uint32_t *)buf
;
106 for (i
= 0; i
< size
/ 4; i
++)
107 p
[i
] = TDB_BYTEREV(p
[i
]);
112 /* read a lump of data at a specified offset, maybe convert */
113 static int tdb_read(struct tdb_context
*tdb
, tdb_off_t off
, void *buf
,
114 tdb_len_t len
, int cv
)
116 if (tdb
->methods
->tdb_oob(tdb
, off
+ len
, 0) != 0) {
121 memcpy(buf
, off
+ (char *)tdb
->map_ptr
, len
);
123 ssize_t ret
= pread(tdb
->fd
, buf
, len
, off
);
124 if (ret
!= (ssize_t
)len
) {
125 /* Ensure ecode is set for log fn. */
126 tdb
->ecode
= TDB_ERR_IO
;
127 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_read failed at %d "
128 "len=%d ret=%d (%s) map_size=%d\n",
129 (int)off
, (int)len
, (int)ret
, strerror(errno
),
130 (int)tdb
->map_size
));
131 return TDB_ERRCODE(TDB_ERR_IO
, -1);
135 tdb_convert(buf
, len
);
143 do an unlocked scan of the hash table heads to find the next non-zero head. The value
144 will then be confirmed with the lock held
146 static void tdb_next_hash_chain(struct tdb_context
*tdb
, uint32_t *chain
)
150 for (;h
< tdb
->header
.hash_size
;h
++) {
151 if (0 != *(uint32_t *)(TDB_HASH_TOP(h
) + (unsigned char *)tdb
->map_ptr
)) {
157 for (;h
< tdb
->header
.hash_size
;h
++) {
158 if (tdb_ofs_read(tdb
, TDB_HASH_TOP(h
), &off
) != 0 || off
!= 0) {
167 int tdb_munmap(struct tdb_context
*tdb
)
169 if (tdb
->flags
& TDB_INTERNAL
)
174 int ret
= munmap(tdb
->map_ptr
, tdb
->map_size
);
183 void tdb_mmap(struct tdb_context
*tdb
)
185 if (tdb
->flags
& TDB_INTERNAL
)
189 if (!(tdb
->flags
& TDB_NOMMAP
)) {
190 tdb
->map_ptr
= mmap(NULL
, tdb
->map_size
,
191 PROT_READ
|(tdb
->read_only
? 0:PROT_WRITE
),
192 MAP_SHARED
|MAP_FILE
, tdb
->fd
, 0);
195 * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
198 if (tdb
->map_ptr
== MAP_FAILED
) {
200 TDB_LOG((tdb
, TDB_DEBUG_WARNING
, "tdb_mmap failed for size %d (%s)\n",
201 tdb
->map_size
, strerror(errno
)));
211 /* expand a file. we prefer to use ftruncate, as that is what posix
212 says to use for mmap expansion */
213 static int tdb_expand_file(struct tdb_context
*tdb
, tdb_off_t size
, tdb_off_t addition
)
217 if (tdb
->read_only
|| tdb
->traverse_read
) {
218 tdb
->ecode
= TDB_ERR_RDONLY
;
222 if (ftruncate(tdb
->fd
, size
+addition
) == -1) {
224 if (pwrite(tdb
->fd
, &b
, 1, (size
+addition
) - 1) != 1) {
225 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "expand_file to %d failed (%s)\n",
226 size
+addition
, strerror(errno
)));
231 /* now fill the file with something. This ensures that the
232 file isn't sparse, which would be very bad if we ran out of
233 disk. This must be done with write, not via mmap */
234 memset(buf
, TDB_PAD_BYTE
, sizeof(buf
));
236 int n
= addition
>sizeof(buf
)?sizeof(buf
):addition
;
237 int ret
= pwrite(tdb
->fd
, buf
, n
, size
);
239 TDB_LOG((tdb
, TDB_DEBUG_FATAL
, "expand_file write of %d failed (%s)\n",
240 n
, strerror(errno
)));
250 /* expand the database at least size bytes by expanding the underlying
251 file and doing the mmap again if necessary */
252 int tdb_expand(struct tdb_context
*tdb
, tdb_off_t size
)
254 struct list_struct rec
;
257 if (tdb_lock(tdb
, -1, F_WRLCK
) == -1) {
258 TDB_LOG((tdb
, TDB_DEBUG_ERROR
, "lock failed in tdb_expand\n"));
262 /* must know about any previous expansions by another process */
263 tdb
->methods
->tdb_oob(tdb
, tdb
->map_size
+ 1, 1);
265 /* always make room for at least 10 more records, and round
266 the database up to a multiple of the page size */
267 size
= TDB_ALIGN(tdb
->map_size
+ size
*10, tdb
->page_size
) - tdb
->map_size
;
269 if (!(tdb
->flags
& TDB_INTERNAL
))
273 * We must ensure the file is unmapped before doing this
274 * to ensure consistency with systems like OpenBSD where
275 * writes and mmaps are not consistent.
278 /* expand the file itself */
279 if (!(tdb
->flags
& TDB_INTERNAL
)) {
280 if (tdb
->methods
->tdb_expand_file(tdb
, tdb
->map_size
, size
) != 0)
284 tdb
->map_size
+= size
;
286 if (tdb
->flags
& TDB_INTERNAL
) {
287 char *new_map_ptr
= (char *)realloc(tdb
->map_ptr
,
290 tdb
->map_size
-= size
;
293 tdb
->map_ptr
= new_map_ptr
;
296 * We must ensure the file is remapped before adding the space
297 * to ensure consistency with systems like OpenBSD where
298 * writes and mmaps are not consistent.
301 /* We're ok if the mmap fails as we'll fallback to read/write */
305 /* form a new freelist record */
306 memset(&rec
,'\0',sizeof(rec
));
307 rec
.rec_len
= size
- sizeof(rec
);
309 /* link it into the free list */
310 offset
= tdb
->map_size
- size
;
311 if (tdb_free(tdb
, offset
, &rec
) == -1)
314 tdb_unlock(tdb
, -1, F_WRLCK
);
317 tdb_unlock(tdb
, -1, F_WRLCK
);
321 /* read/write a tdb_off_t */
322 int tdb_ofs_read(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_off_t
*d
)
324 return tdb
->methods
->tdb_read(tdb
, offset
, (char*)d
, sizeof(*d
), DOCONV());
327 int tdb_ofs_write(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_off_t
*d
)
330 return tdb
->methods
->tdb_write(tdb
, offset
, CONVERT(off
), sizeof(*d
));
334 /* read a lump of data, allocating the space for it */
335 unsigned char *tdb_alloc_read(struct tdb_context
*tdb
, tdb_off_t offset
, tdb_len_t len
)
339 /* some systems don't like zero length malloc */
344 if (!(buf
= (unsigned char *)malloc(len
))) {
345 /* Ensure ecode is set for log fn. */
346 tdb
->ecode
= TDB_ERR_OOM
;
347 TDB_LOG((tdb
, TDB_DEBUG_ERROR
,"tdb_alloc_read malloc failed len=%d (%s)\n",
348 len
, strerror(errno
)));
349 return TDB_ERRCODE(TDB_ERR_OOM
, buf
);
351 if (tdb
->methods
->tdb_read(tdb
, offset
, buf
, len
, 0) == -1) {
358 /* Give a piece of tdb data to a parser */
360 int tdb_parse_data(struct tdb_context
*tdb
, TDB_DATA key
,
361 tdb_off_t offset
, tdb_len_t len
,
362 int (*parser
)(TDB_DATA key
, TDB_DATA data
,
371 if ((tdb
->transaction
== NULL
) && (tdb
->map_ptr
!= NULL
)) {
373 * Optimize by avoiding the malloc/memcpy/free, point the
374 * parser directly at the mmap area.
376 if (tdb
->methods
->tdb_oob(tdb
, offset
+len
, 0) != 0) {
379 data
.dptr
= offset
+ (unsigned char *)tdb
->map_ptr
;
380 return parser(key
, data
, private_data
);
383 if (!(data
.dptr
= tdb_alloc_read(tdb
, offset
, len
))) {
387 result
= parser(key
, data
, private_data
);
392 /* read/write a record */
393 int tdb_rec_read(struct tdb_context
*tdb
, tdb_off_t offset
, struct list_struct
*rec
)
395 if (tdb
->methods
->tdb_read(tdb
, offset
, rec
, sizeof(*rec
),DOCONV()) == -1)
397 if (TDB_BAD_MAGIC(rec
)) {
398 /* Ensure ecode is set for log fn. */
399 tdb
->ecode
= TDB_ERR_CORRUPT
;
400 TDB_LOG((tdb
, TDB_DEBUG_FATAL
,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec
->magic
, offset
));
401 return TDB_ERRCODE(TDB_ERR_CORRUPT
, -1);
403 return tdb
->methods
->tdb_oob(tdb
, rec
->next
+sizeof(*rec
), 0);
406 int tdb_rec_write(struct tdb_context
*tdb
, tdb_off_t offset
, struct list_struct
*rec
)
408 struct list_struct r
= *rec
;
409 return tdb
->methods
->tdb_write(tdb
, offset
, CONVERT(r
), sizeof(r
));
412 static const struct tdb_methods io_methods
= {
422 initialise the default methods table
424 void tdb_io_init(struct tdb_context
*tdb
)
426 tdb
->methods
= &io_methods
;