tdb: Slightly simplify tdb_expand_file
[samba.git] / lib / tdb / common / 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 "tdb_private.h"
30
31 /* check for an out of bounds access - if it is out of bounds then
32    see if the database has been expanded by someone else and expand
33    if necessary
34 */
35 static int tdb_oob(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len,
36                    int probe)
37 {
38         struct stat st;
39         if (len + off < len) {
40                 if (!probe) {
41                         /* Ensure ecode is set for log fn. */
42                         tdb->ecode = TDB_ERR_IO;
43                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob off %d len %d wrap\n",
44                                  (int)off, (int)len));
45                 }
46                 return -1;
47         }
48
49         if (off + len <= tdb->map_size)
50                 return 0;
51         if (tdb->flags & TDB_INTERNAL) {
52                 if (!probe) {
53                         /* Ensure ecode is set for log fn. */
54                         tdb->ecode = TDB_ERR_IO;
55                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %u beyond internal malloc size %u\n",
56                                  (int)(off + len), (int)tdb->map_size));
57                 }
58                 return -1;
59         }
60
61         if (fstat(tdb->fd, &st) == -1) {
62                 tdb->ecode = TDB_ERR_IO;
63                 return -1;
64         }
65
66         /* Beware >4G files! */
67         if ((tdb_off_t)st.st_size != st.st_size) {
68                 /* Ensure ecode is set for log fn. */
69                 tdb->ecode = TDB_ERR_IO;
70                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_oob len %llu too large!\n",
71                          (long long)st.st_size));
72                 return -1;
73         }
74
75         /* Unmap, update size, remap.  We do this unconditionally, to handle
76          * the unusual case where the db is truncated.
77          *
78          * This can happen to a child using tdb_reopen_all(true) on a
79          * TDB_CLEAR_IF_FIRST tdb whose parent crashes: the next
80          * opener will truncate the database. */
81         if (tdb_munmap(tdb) == -1) {
82                 tdb->ecode = TDB_ERR_IO;
83                 return -1;
84         }
85         tdb->map_size = st.st_size;
86         if (tdb_mmap(tdb) != 0) {
87                 return - 1;
88         }
89
90         if (st.st_size < (size_t)off + len) {
91                 if (!probe) {
92                         /* Ensure ecode is set for log fn. */
93                         tdb->ecode = TDB_ERR_IO;
94                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_oob len %u beyond eof at %u\n",
95                                  (int)(off + len), (int)st.st_size));
96                 }
97                 return -1;
98         }
99         return 0;
100 }
101
102 /* write a lump of data at a specified offset */
103 static int tdb_write(struct tdb_context *tdb, tdb_off_t off,
104                      const void *buf, tdb_len_t len)
105 {
106         if (len == 0) {
107                 return 0;
108         }
109
110         if (tdb->read_only || tdb->traverse_read) {
111                 tdb->ecode = TDB_ERR_RDONLY;
112                 return -1;
113         }
114
115         if (tdb->methods->tdb_oob(tdb, off, len, 0) != 0)
116                 return -1;
117
118         if (tdb->map_ptr) {
119                 memcpy(off + (char *)tdb->map_ptr, buf, len);
120         } else {
121 #ifdef HAVE_INCOHERENT_MMAP
122                 tdb->ecode = TDB_ERR_IO;
123                 return -1;
124 #else
125                 ssize_t written = pwrite(tdb->fd, buf, len, off);
126                 if ((written != (ssize_t)len) && (written != -1)) {
127                         /* try once more */
128                         tdb->ecode = TDB_ERR_IO;
129                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
130                                  "%d of %d bytes at %d, trying once more\n",
131                                  (int)written, len, off));
132                         written = pwrite(tdb->fd, (const char *)buf+written,
133                                          len-written,
134                                          off+written);
135                 }
136                 if (written == -1) {
137                         /* Ensure ecode is set for log fn. */
138                         tdb->ecode = TDB_ERR_IO;
139                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
140                                  "len=%d (%s)\n", off, len, strerror(errno)));
141                         return -1;
142                 } else if (written != (ssize_t)len) {
143                         tdb->ecode = TDB_ERR_IO;
144                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
145                                  "write %d bytes at %d in two attempts\n",
146                                  len, off));
147                         return -1;
148                 }
149 #endif
150         }
151         return 0;
152 }
153
154 /* Endian conversion: we only ever deal with 4 byte quantities */
155 void *tdb_convert(void *buf, uint32_t size)
156 {
157         uint32_t i, *p = (uint32_t *)buf;
158         for (i = 0; i < size / 4; i++)
159                 p[i] = TDB_BYTEREV(p[i]);
160         return buf;
161 }
162
163
164 /* read a lump of data at a specified offset, maybe convert */
165 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
166                     tdb_len_t len, int cv)
167 {
168         if (tdb->methods->tdb_oob(tdb, off, len, 0) != 0) {
169                 return -1;
170         }
171
172         if (tdb->map_ptr) {
173                 memcpy(buf, off + (char *)tdb->map_ptr, len);
174         } else {
175 #ifdef HAVE_INCOHERENT_MMAP
176                 tdb->ecode = TDB_ERR_IO;
177                 return -1;
178 #else
179                 ssize_t ret = pread(tdb->fd, buf, len, off);
180                 if (ret != (ssize_t)len) {
181                         /* Ensure ecode is set for log fn. */
182                         tdb->ecode = TDB_ERR_IO;
183                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_read failed at %d "
184                                  "len=%d ret=%d (%s) map_size=%d\n",
185                                  (int)off, (int)len, (int)ret, strerror(errno),
186                                  (int)tdb->map_size));
187                         return -1;
188                 }
189 #endif
190         }
191         if (cv) {
192                 tdb_convert(buf, len);
193         }
194         return 0;
195 }
196
197
198
199 /*
200   do an unlocked scan of the hash table heads to find the next non-zero head. The value
201   will then be confirmed with the lock held
202 */
203 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
204 {
205         uint32_t h = *chain;
206         if (tdb->map_ptr) {
207                 for (;h < tdb->hash_size;h++) {
208                         if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
209                                 break;
210                         }
211                 }
212         } else {
213                 uint32_t off=0;
214                 for (;h < tdb->hash_size;h++) {
215                         if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
216                                 break;
217                         }
218                 }
219         }
220         (*chain) = h;
221 }
222
223
224 int tdb_munmap(struct tdb_context *tdb)
225 {
226         if (tdb->flags & TDB_INTERNAL)
227                 return 0;
228
229 #ifdef HAVE_MMAP
230         if (tdb->map_ptr) {
231                 int ret;
232
233                 ret = munmap(tdb->map_ptr, tdb->map_size);
234                 if (ret != 0)
235                         return ret;
236         }
237 #endif
238         tdb->map_ptr = NULL;
239         return 0;
240 }
241
242 /* If mmap isn't coherent, *everyone* must always mmap. */
243 static bool should_mmap(const struct tdb_context *tdb)
244 {
245 #ifdef HAVE_INCOHERENT_MMAP
246         return true;
247 #else
248         return !(tdb->flags & TDB_NOMMAP);
249 #endif
250 }
251
252 int tdb_mmap(struct tdb_context *tdb)
253 {
254         if (tdb->flags & TDB_INTERNAL)
255                 return 0;
256
257 #ifdef HAVE_MMAP
258         if (should_mmap(tdb)) {
259                 tdb->map_ptr = mmap(NULL, tdb->map_size,
260                                     PROT_READ|(tdb->read_only? 0:PROT_WRITE),
261                                     MAP_SHARED|MAP_FILE, tdb->fd, 0);
262
263                 /*
264                  * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
265                  */
266
267                 if (tdb->map_ptr == MAP_FAILED) {
268                         tdb->map_ptr = NULL;
269                         TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_mmap failed for size %d (%s)\n",
270                                  tdb->map_size, strerror(errno)));
271 #ifdef HAVE_INCOHERENT_MMAP
272                         tdb->ecode = TDB_ERR_IO;
273                         return -1;
274 #endif
275                 }
276         } else {
277                 tdb->map_ptr = NULL;
278         }
279 #else
280         tdb->map_ptr = NULL;
281 #endif
282         return 0;
283 }
284
285 /* expand a file.  we prefer to use ftruncate, as that is what posix
286   says to use for mmap expansion */
287 static int tdb_expand_file(struct tdb_context *tdb, tdb_off_t size, tdb_off_t addition)
288 {
289         char buf[8192];
290
291         if (tdb->read_only || tdb->traverse_read) {
292                 tdb->ecode = TDB_ERR_RDONLY;
293                 return -1;
294         }
295
296         if (ftruncate(tdb->fd, size+addition) == -1) {
297                 char b = 0;
298                 ssize_t written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
299                 if (written == 0) {
300                         /* try once more, potentially revealing errno */
301                         written = pwrite(tdb->fd,  &b, 1, (size+addition) - 1);
302                 }
303                 if (written == 0) {
304                         /* again - give up, guessing errno */
305                         errno = ENOSPC;
306                 }
307                 if (written != 1) {
308                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file to %d failed (%s)\n",
309                                  size+addition, strerror(errno)));
310                         return -1;
311                 }
312         }
313
314         /* now fill the file with something. This ensures that the
315            file isn't sparse, which would be very bad if we ran out of
316            disk. This must be done with write, not via mmap */
317         memset(buf, TDB_PAD_BYTE, sizeof(buf));
318         while (addition) {
319                 size_t n = addition>sizeof(buf)?sizeof(buf):addition;
320                 ssize_t written = pwrite(tdb->fd, buf, n, size);
321                 if (written == 0) {
322                         /* prevent infinite loops: try _once_ more */
323                         written = pwrite(tdb->fd, buf, n, size);
324                 }
325                 if (written == 0) {
326                         /* give up, trying to provide a useful errno */
327                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write "
328                                 "returned 0 twice: giving up!\n"));
329                         errno = ENOSPC;
330                         return -1;
331                 }
332                 if (written == -1) {
333                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of "
334                                  "%d bytes failed (%s)\n", (int)n,
335                                  strerror(errno)));
336                         return -1;
337                 }
338                 if (written != n) {
339                         TDB_LOG((tdb, TDB_DEBUG_WARNING, "expand_file: wrote "
340                                  "only %d of %d bytes - retrying\n", (int)written,
341                                  (int)n));
342                 }
343                 addition -= written;
344                 size += written;
345         }
346         return 0;
347 }
348
349
350 /* You need 'size', this tells you how much you should expand by. */
351 tdb_off_t tdb_expand_adjust(tdb_off_t map_size, tdb_off_t size, int page_size)
352 {
353         tdb_off_t new_size, top_size;
354
355         /* limit size in order to avoid using up huge amounts of memory for
356          * in memory tdbs if an oddball huge record creeps in */
357         if (size > 100 * 1024) {
358                 top_size = map_size + size * 2;
359         } else {
360                 top_size = map_size + size * 100;
361         }
362
363         /* always make room for at least top_size more records, and at
364            least 25% more space. if the DB is smaller than 100MiB,
365            otherwise grow it by 10% only. */
366         if (map_size > 100 * 1024 * 1024) {
367                 new_size = map_size * 1.10;
368         } else {
369                 new_size = map_size * 1.25;
370         }
371
372         /* Round the database up to a multiple of the page size */
373         new_size = MAX(top_size, new_size);
374         return TDB_ALIGN(new_size, page_size) - map_size;
375 }
376
377 /* expand the database at least size bytes by expanding the underlying
378    file and doing the mmap again if necessary */
379 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
380 {
381         struct tdb_record rec;
382         tdb_off_t offset;
383
384         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
385                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
386                 return -1;
387         }
388
389         /* must know about any previous expansions by another process */
390         tdb->methods->tdb_oob(tdb, tdb->map_size, 1, 1);
391
392         size = tdb_expand_adjust(tdb->map_size, size, tdb->page_size);
393
394         /* expand the file itself */
395         if (!(tdb->flags & TDB_INTERNAL)) {
396                 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
397                         goto fail;
398         }
399
400         /* form a new freelist record */
401         offset = tdb->map_size;
402         memset(&rec,'\0',sizeof(rec));
403         rec.rec_len = size - sizeof(rec);
404
405         if (tdb->flags & TDB_INTERNAL) {
406                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
407                                                     tdb->map_size + size);
408                 if (!new_map_ptr) {
409                         goto fail;
410                 }
411                 tdb->map_ptr = new_map_ptr;
412                 tdb->map_size += size;
413         } else {
414                 /* Explicitly remap: if we're in a transaction, this won't
415                  * happen automatically! */
416                 tdb_munmap(tdb);
417                 tdb->map_size += size;
418                 if (tdb_mmap(tdb) != 0) {
419                         goto fail;
420                 }
421         }
422
423         /* link it into the free list */
424         if (tdb_free(tdb, offset, &rec) == -1)
425                 goto fail;
426
427         tdb_unlock(tdb, -1, F_WRLCK);
428         return 0;
429  fail:
430         tdb_unlock(tdb, -1, F_WRLCK);
431         return -1;
432 }
433
434 /* read/write a tdb_off_t */
435 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
436 {
437         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
438 }
439
440 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
441 {
442         tdb_off_t off = *d;
443         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
444 }
445
446
447 /* read a lump of data, allocating the space for it */
448 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
449 {
450         unsigned char *buf;
451
452         /* some systems don't like zero length malloc */
453
454         if (!(buf = (unsigned char *)malloc(len ? len : 1))) {
455                 /* Ensure ecode is set for log fn. */
456                 tdb->ecode = TDB_ERR_OOM;
457                 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
458                            len, strerror(errno)));
459                 return NULL;
460         }
461         if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
462                 SAFE_FREE(buf);
463                 return NULL;
464         }
465         return buf;
466 }
467
468 /* Give a piece of tdb data to a parser */
469
470 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
471                    tdb_off_t offset, tdb_len_t len,
472                    int (*parser)(TDB_DATA key, TDB_DATA data,
473                                  void *private_data),
474                    void *private_data)
475 {
476         TDB_DATA data;
477         int result;
478
479         data.dsize = len;
480
481         if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
482                 /*
483                  * Optimize by avoiding the malloc/memcpy/free, point the
484                  * parser directly at the mmap area.
485                  */
486                 if (tdb->methods->tdb_oob(tdb, offset, len, 0) != 0) {
487                         return -1;
488                 }
489                 data.dptr = offset + (unsigned char *)tdb->map_ptr;
490                 return parser(key, data, private_data);
491         }
492
493         if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
494                 return -1;
495         }
496
497         result = parser(key, data, private_data);
498         free(data.dptr);
499         return result;
500 }
501
502 /* read/write a record */
503 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
504 {
505         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
506                 return -1;
507         if (TDB_BAD_MAGIC(rec)) {
508                 /* Ensure ecode is set for log fn. */
509                 tdb->ecode = TDB_ERR_CORRUPT;
510                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
511                 return -1;
512         }
513         return tdb->methods->tdb_oob(tdb, rec->next, sizeof(*rec), 0);
514 }
515
516 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
517 {
518         struct tdb_record r = *rec;
519         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
520 }
521
522 static const struct tdb_methods io_methods = {
523         tdb_read,
524         tdb_write,
525         tdb_next_hash_chain,
526         tdb_oob,
527         tdb_expand_file,
528 };
529
530 /*
531   initialise the default methods table
532 */
533 void tdb_io_init(struct tdb_context *tdb)
534 {
535         tdb->methods = &io_methods;
536 }