tdb2: Make TDB1 code use TDB2's open flags.
[ccan] / ccan / tdb2 / tdb1_io.c
1  /*
2    Unix SMB/CIFS implementation.
3
4    trivial database library
5
6    Copyright (C) Andrew Tridgell              1999-2005
7    Copyright (C) Paul `Rusty' Russell              2000
8    Copyright (C) Jeremy Allison                    2000-2003
9
10      ** NOTE! The following LGPL license applies to the tdb
11      ** library. This does NOT imply that all of Samba is released
12      ** under the LGPL
13
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.
18
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.
23
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/>.
26 */
27
28
29 #include "tdb1_private.h"
30 #ifndef MAX
31 #define MAX(a,b) ((a) > (b) ? (a) : (b))
32 #endif
33
34 /* check for an out of bounds access - if it is out of bounds then
35    see if the database has been expanded by someone else and expand
36    if necessary
37    note that "len" is the minimum length needed for the db
38 */
39 static int tdb1_oob(struct tdb1_context *tdb, tdb1_off_t len, int probe)
40 {
41         struct stat st;
42         if (len <= tdb->map_size)
43                 return 0;
44         if (tdb->flags & TDB_INTERNAL) {
45                 if (!probe) {
46                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
47                                                 "tdb1_oob len %d beyond internal malloc size %d",
48                                                 (int)len, (int)tdb->map_size);
49                 }
50                 return -1;
51         }
52
53         if (fstat(tdb->fd, &st) == -1) {
54                 tdb->last_error = TDB_ERR_IO;
55                 return -1;
56         }
57
58         if (st.st_size < (size_t)len) {
59                 if (!probe) {
60                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
61                                                 "tdb1_oob len %d beyond eof at %d",
62                                                 (int)len, (int)st.st_size);
63                 }
64                 return -1;
65         }
66
67         /* Unmap, update size, remap */
68         if (tdb1_munmap(tdb) == -1) {
69                 tdb->last_error = TDB_ERR_IO;
70                 return -1;
71         }
72         tdb->map_size = st.st_size;
73         tdb1_mmap(tdb);
74         return 0;
75 }
76
77 /* write a lump of data at a specified offset */
78 static int tdb1_write(struct tdb1_context *tdb, tdb1_off_t off,
79                      const void *buf, tdb1_len_t len)
80 {
81         if (len == 0) {
82                 return 0;
83         }
84
85         if (tdb->read_only || tdb->traverse_read) {
86                 tdb->last_error = TDB_ERR_RDONLY;
87                 return -1;
88         }
89
90         if (tdb->methods->tdb1_oob(tdb, off + len, 0) != 0)
91                 return -1;
92
93         if (tdb->map_ptr) {
94                 memcpy(off + (char *)tdb->map_ptr, buf, len);
95         } else {
96                 ssize_t written = pwrite(tdb->fd, buf, len, off);
97                 if ((written != (ssize_t)len) && (written != -1)) {
98                         tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
99                                    "tdb1_write: wrote only "
100                                    "%d of %d bytes at %d, trying once more",
101                                    (int)written, len, off);
102                         written = pwrite(tdb->fd, (const char *)buf+written,
103                                          len-written,
104                                          off+written);
105                 }
106                 if (written == -1) {
107                         /* Ensure ecode is set for log fn. */
108                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
109                                                 "tdb1_write failed at %d "
110                                                 "len=%d (%s)",
111                                                 off, len, strerror(errno));
112                         return -1;
113                 } else if (written != (ssize_t)len) {
114                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
115                                                 "tdb1_write: failed to "
116                                                 "write %d bytes at %d in two attempts",
117                                                 len, off);
118                         return -1;
119                 }
120         }
121         return 0;
122 }
123
124 /* Endian conversion: we only ever deal with 4 byte quantities */
125 void *tdb1_convert(void *buf, uint32_t size)
126 {
127         uint32_t i, *p = (uint32_t *)buf;
128         for (i = 0; i < size / 4; i++)
129                 p[i] = TDB1_BYTEREV(p[i]);
130         return buf;
131 }
132
133
134 /* read a lump of data at a specified offset, maybe convert */
135 static int tdb1_read(struct tdb1_context *tdb, tdb1_off_t off, void *buf,
136                     tdb1_len_t len, int cv)
137 {
138         if (tdb->methods->tdb1_oob(tdb, off + len, 0) != 0) {
139                 return -1;
140         }
141
142         if (tdb->map_ptr) {
143                 memcpy(buf, off + (char *)tdb->map_ptr, len);
144         } else {
145                 ssize_t ret = pread(tdb->fd, buf, len, off);
146                 if (ret != (ssize_t)len) {
147                         /* Ensure ecode is set for log fn. */
148                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
149                                                 "tdb1_read failed at %d "
150                                                 "len=%d ret=%d (%s) map_size=%d",
151                                                 (int)off, (int)len, (int)ret,
152                                                 strerror(errno),
153                                                 (int)tdb->map_size);
154                         return -1;
155                 }
156         }
157         if (cv) {
158                 tdb1_convert(buf, len);
159         }
160         return 0;
161 }
162
163
164
165 /*
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
168 */
169 static void tdb1_next_hash_chain(struct tdb1_context *tdb, uint32_t *chain)
170 {
171         uint32_t h = *chain;
172         if (tdb->map_ptr) {
173                 for (;h < tdb->header.hash_size;h++) {
174                         if (0 != *(uint32_t *)(TDB1_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
175                                 break;
176                         }
177                 }
178         } else {
179                 uint32_t off=0;
180                 for (;h < tdb->header.hash_size;h++) {
181                         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(h), &off) != 0 || off != 0) {
182                                 break;
183                         }
184                 }
185         }
186         (*chain) = h;
187 }
188
189
190 int tdb1_munmap(struct tdb1_context *tdb)
191 {
192         if (tdb->flags & TDB_INTERNAL)
193                 return 0;
194
195 #if HAVE_MMAP
196         if (tdb->map_ptr) {
197                 int ret;
198
199                 ret = munmap(tdb->map_ptr, tdb->map_size);
200                 if (ret != 0)
201                         return ret;
202         }
203 #endif
204         tdb->map_ptr = NULL;
205         return 0;
206 }
207
208 void tdb1_mmap(struct tdb1_context *tdb)
209 {
210         if (tdb->flags & TDB_INTERNAL)
211                 return;
212
213 #if HAVE_MMAP
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|MAP_FILE, tdb->fd, 0);
218
219                 /*
220                  * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
221                  */
222
223                 if (tdb->map_ptr == MAP_FAILED) {
224                         tdb->map_ptr = NULL;
225                         tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
226                                    "tdb1_mmap failed for size %d (%s)",
227                                    tdb->map_size, strerror(errno));
228                 }
229         } else {
230                 tdb->map_ptr = NULL;
231         }
232 #else
233         tdb->map_ptr = NULL;
234 #endif
235 }
236
237 /* expand a file.  we prefer to use ftruncate, as that is what posix
238   says to use for mmap expansion */
239 static int tdb1_expand_file(struct tdb1_context *tdb, tdb1_off_t size, tdb1_off_t addition)
240 {
241         char buf[8192];
242
243         if (tdb->read_only || tdb->traverse_read) {
244                 tdb->last_error = TDB_ERR_RDONLY;
245                 return -1;
246         }
247
248         if (ftruncate(tdb->fd, size+addition) == -1) {
249                 char b = 0;
250                 ssize_t written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
251                 if (written == 0) {
252                         /* try once more, potentially revealing errno */
253                         written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
254                 }
255                 if (written == 0) {
256                         /* again - give up, guessing errno */
257                         errno = ENOSPC;
258                 }
259                 if (written != 1) {
260                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
261                                                 "expand_file to %d failed (%s)",
262                                                 size+addition,
263                                                 strerror(errno));
264                         return -1;
265                 }
266         }
267
268         /* now fill the file with something. This ensures that the
269            file isn't sparse, which would be very bad if we ran out of
270            disk. This must be done with write, not via mmap */
271         memset(buf, TDB1_PAD_BYTE, sizeof(buf));
272         while (addition) {
273                 size_t n = addition>sizeof(buf)?sizeof(buf):addition;
274                 ssize_t written = pwrite(tdb->fd, buf, n, size);
275                 if (written == 0) {
276                         /* prevent infinite loops: try _once_ more */
277                         written = pwrite(tdb->fd, buf, n, size);
278                 }
279                 if (written == 0) {
280                         /* give up, trying to provide a useful errno */
281                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
282                                                 "expand_file write "
283                                                 "returned 0 twice: giving up!");
284                         errno = ENOSPC;
285                         return -1;
286                 } else if (written == -1) {
287                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_ERROR,
288                                                 "expand_file write of "
289                                                 "%d bytes failed (%s)", (int)n,
290                                                 strerror(errno));
291                         return -1;
292                 } else if (written != n) {
293                         tdb_logerr(tdb, TDB_ERR_IO, TDB_LOG_WARNING,
294                                    "expand_file: wrote "
295                                    "only %d of %d bytes - retrying",
296                                    (int)written, (int)n);
297                 }
298                 addition -= written;
299                 size += written;
300         }
301         return 0;
302 }
303
304
305 /* expand the database at least size bytes by expanding the underlying
306    file and doing the mmap again if necessary */
307 int tdb1_expand(struct tdb1_context *tdb, tdb1_off_t size)
308 {
309         struct tdb1_record rec;
310         tdb1_off_t offset, new_size, top_size, map_size;
311
312         if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
313                 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
314                            "lock failed in tdb1_expand");
315                 return -1;
316         }
317
318         /* must know about any previous expansions by another process */
319         tdb->methods->tdb1_oob(tdb, tdb->map_size + 1, 1);
320
321         /* limit size in order to avoid using up huge amounts of memory for
322          * in memory tdbs if an oddball huge record creeps in */
323         if (size > 100 * 1024) {
324                 top_size = tdb->map_size + size * 2;
325         } else {
326                 top_size = tdb->map_size + size * 100;
327         }
328
329         /* always make room for at least top_size more records, and at
330            least 25% more space. if the DB is smaller than 100MiB,
331            otherwise grow it by 10% only. */
332         if (tdb->map_size > 100 * 1024 * 1024) {
333                 map_size = tdb->map_size * 1.10;
334         } else {
335                 map_size = tdb->map_size * 1.25;
336         }
337
338         /* Round the database up to a multiple of the page size */
339         new_size = MAX(top_size, map_size);
340         size = TDB1_ALIGN(new_size, tdb->page_size) - tdb->map_size;
341
342         if (!(tdb->flags & TDB_INTERNAL))
343                 tdb1_munmap(tdb);
344
345         /*
346          * We must ensure the file is unmapped before doing this
347          * to ensure consistency with systems like OpenBSD where
348          * writes and mmaps are not consistent.
349          */
350
351         /* expand the file itself */
352         if (!(tdb->flags & TDB_INTERNAL)) {
353                 if (tdb->methods->tdb1_expand_file(tdb, tdb->map_size, size) != 0)
354                         goto fail;
355         }
356
357         tdb->map_size += size;
358
359         if (tdb->flags & TDB_INTERNAL) {
360                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
361                                                     tdb->map_size);
362                 if (!new_map_ptr) {
363                         tdb->map_size -= size;
364                         goto fail;
365                 }
366                 tdb->map_ptr = new_map_ptr;
367         } else {
368                 /*
369                  * We must ensure the file is remapped before adding the space
370                  * to ensure consistency with systems like OpenBSD where
371                  * writes and mmaps are not consistent.
372                  */
373
374                 /* We're ok if the mmap fails as we'll fallback to read/write */
375                 tdb1_mmap(tdb);
376         }
377
378         /* form a new freelist record */
379         memset(&rec,'\0',sizeof(rec));
380         rec.rec_len = size - sizeof(rec);
381
382         /* link it into the free list */
383         offset = tdb->map_size - size;
384         if (tdb1_free(tdb, offset, &rec) == -1)
385                 goto fail;
386
387         tdb1_unlock(tdb, -1, F_WRLCK);
388         return 0;
389  fail:
390         tdb1_unlock(tdb, -1, F_WRLCK);
391         return -1;
392 }
393
394 /* read/write a tdb1_off_t */
395 int tdb1_ofs_read(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
396 {
397         return tdb->methods->tdb1_read(tdb, offset, (char*)d, sizeof(*d), TDB1_DOCONV());
398 }
399
400 int tdb1_ofs_write(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_off_t *d)
401 {
402         tdb1_off_t off = *d;
403         return tdb->methods->tdb1_write(tdb, offset, TDB1_CONV(off), sizeof(*d));
404 }
405
406
407 /* read a lump of data, allocating the space for it */
408 unsigned char *tdb1_alloc_read(struct tdb1_context *tdb, tdb1_off_t offset, tdb1_len_t len)
409 {
410         unsigned char *buf;
411
412         /* some systems don't like zero length malloc */
413
414         if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
415                 tdb->last_error = tdb_logerr(tdb, TDB_ERR_OOM, TDB_LOG_ERROR,
416                                              "tdb1_alloc_read malloc failed"
417                                              " len=%d (%s)",
418                                              len, strerror(errno));
419                 return NULL;
420         }
421         if (tdb->methods->tdb1_read(tdb, offset, buf, len, 0) == -1) {
422                 SAFE_FREE(buf);
423                 return NULL;
424         }
425         return buf;
426 }
427
428 /* Give a piece of tdb data to a parser */
429
430 int tdb1_parse_data(struct tdb1_context *tdb, TDB_DATA key,
431                    tdb1_off_t offset, tdb1_len_t len,
432                    int (*parser)(TDB_DATA key, TDB_DATA data,
433                                  void *private_data),
434                    void *private_data)
435 {
436         TDB_DATA data;
437         int result;
438
439         data.dsize = len;
440
441         if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
442                 /*
443                  * Optimize by avoiding the malloc/memcpy/free, point the
444                  * parser directly at the mmap area.
445                  */
446                 if (tdb->methods->tdb1_oob(tdb, offset+len, 0) != 0) {
447                         return -1;
448                 }
449                 data.dptr = offset + (unsigned char *)tdb->map_ptr;
450                 return parser(key, data, private_data);
451         }
452
453         if (!(data.dptr = tdb1_alloc_read(tdb, offset, len))) {
454                 return -1;
455         }
456
457         result = parser(key, data, private_data);
458         free(data.dptr);
459         return result;
460 }
461
462 /* read/write a record */
463 int tdb1_rec_read(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
464 {
465         if (tdb->methods->tdb1_read(tdb, offset, rec, sizeof(*rec),TDB1_DOCONV()) == -1)
466                 return -1;
467         if (TDB1_BAD_MAGIC(rec)) {
468                 tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
469                                         "tdb1_rec_read bad magic 0x%x at offset=%d",
470                                         rec->magic, offset);
471                 return -1;
472         }
473         return tdb->methods->tdb1_oob(tdb, rec->next+sizeof(*rec), 0);
474 }
475
476 int tdb1_rec_write(struct tdb1_context *tdb, tdb1_off_t offset, struct tdb1_record *rec)
477 {
478         struct tdb1_record r = *rec;
479         return tdb->methods->tdb1_write(tdb, offset, TDB1_CONV(r), sizeof(r));
480 }
481
482 static const struct tdb1_methods io1_methods = {
483         tdb1_read,
484         tdb1_write,
485         tdb1_next_hash_chain,
486         tdb1_oob,
487         tdb1_expand_file,
488 };
489
490 /*
491   initialise the default methods table
492 */
493 void tdb1_io_init(struct tdb1_context *tdb)
494 {
495         tdb->methods = &io1_methods;
496 }