tdb2: tdb_expand on empty database now tested.
[ccan] / ccan / tdb2 / 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    Copyright (C) Rusty Russell                     2010
10
11      ** NOTE! The following LGPL license applies to the tdb
12      ** library. This does NOT imply that all of Samba is released
13      ** under the LGPL
14
15    This library is free software; you can redistribute it and/or
16    modify it under the terms of the GNU Lesser General Public
17    License as published by the Free Software Foundation; either
18    version 3 of the License, or (at your option) any later version.
19
20    This library is distributed in the hope that it will be useful,
21    but WITHOUT ANY WARRANTY; without even the implied warranty of
22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23    Lesser General Public License for more details.
24
25    You should have received a copy of the GNU Lesser General Public
26    License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 */
28 #include "private.h"
29 #include <ccan/likely/likely.h>
30
31 void tdb_munmap(struct tdb_context *tdb)
32 {
33         if (tdb->flags & TDB_INTERNAL)
34                 return;
35
36         if (tdb->map_ptr) {
37                 munmap(tdb->map_ptr, tdb->map_size);
38                 tdb->map_ptr = NULL;
39         }
40 }
41
42 void tdb_mmap(struct tdb_context *tdb)
43 {
44         if (tdb->flags & TDB_INTERNAL)
45                 return;
46
47         if (tdb->flags & TDB_NOMMAP)
48                 return;
49
50         tdb->map_ptr = mmap(NULL, tdb->map_size, 
51                             PROT_READ|(tdb->read_only? 0:PROT_WRITE), 
52                             MAP_SHARED, tdb->fd, 0);
53
54         /*
55          * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
56          */
57         if (tdb->map_ptr == MAP_FAILED) {
58                 tdb->map_ptr = NULL;
59                 tdb->log(tdb, TDB_DEBUG_WARNING, tdb->log_priv,
60                          "tdb_mmap failed for size %lld (%s)\n", 
61                          (long long)tdb->map_size, strerror(errno));
62         }
63 }
64
65 /* check for an out of bounds access - if it is out of bounds then
66    see if the database has been expanded by someone else and expand
67    if necessary 
68    note that "len" is the minimum length needed for the db
69 */
70 static int tdb_oob(struct tdb_context *tdb, tdb_off_t len, bool probe)
71 {
72         struct stat st;
73         if (len <= tdb->map_size)
74                 return 0;
75         if (tdb->flags & TDB_INTERNAL) {
76                 if (!probe) {
77                         /* Ensure ecode is set for log fn. */
78                         tdb->ecode = TDB_ERR_IO;
79                         tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
80                                  "tdb_oob len %lld beyond internal"
81                                  " malloc size %lld\n",
82                                  (long long)len,
83                                  (long long)tdb->map_size);
84                 }
85                 return -1;
86         }
87
88         if (fstat(tdb->fd, &st) == -1) {
89                 tdb->ecode = TDB_ERR_IO;
90                 return -1;
91         }
92
93         if (st.st_size < (size_t)len) {
94                 if (!probe) {
95                         /* Ensure ecode is set for log fn. */
96                         tdb->ecode = TDB_ERR_IO;
97                         tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
98                                  "tdb_oob len %lld beyond eof at %lld\n",
99                                  (long long)len, (long long)st.st_size);
100                 }
101                 return -1;
102         }
103
104         /* Unmap, update size, remap */
105         tdb_munmap(tdb);
106         tdb->map_size = st.st_size;
107         tdb_mmap(tdb);
108         return 0;
109 }
110
111 static void *tdb_direct(struct tdb_context *tdb, tdb_off_t off, size_t len)
112 {
113         if (unlikely(!tdb->map_ptr))
114                 return NULL;
115
116         /* FIXME: We can do a subset of this! */
117         if (tdb->transaction)
118                 return NULL;
119
120         if (unlikely(tdb_oob(tdb, off + len, true) == -1))
121                 return NULL;
122         return (char *)tdb->map_ptr + off;
123 }
124
125 /* Either make a copy into pad and return that, or return ptr into mmap. */
126 /* Note: pad has to be a real object, so we can't get here if len
127  * overflows size_t */
128 void *tdb_get(struct tdb_context *tdb, tdb_off_t off, void *pad, size_t len)
129 {
130         if (likely(!(tdb->flags & TDB_CONVERT))) {
131                 void *ret = tdb_direct(tdb, off, len);
132                 if (ret)
133                         return ret;
134         }
135
136         if (unlikely(tdb_oob(tdb, off + len, false) == -1))
137                 return NULL;
138
139         if (tdb->methods->read(tdb, off, pad, len) == -1)
140                 return NULL;
141         return tdb_convert(tdb, pad, len);
142 }
143
144 /* Endian conversion: we only ever deal with 8 byte quantities */
145 void *tdb_convert(const struct tdb_context *tdb, void *buf, tdb_len_t size)
146 {
147         if (unlikely((tdb->flags & TDB_CONVERT))) {
148                 uint64_t i, *p = (uint64_t *)buf;
149                 for (i = 0; i < size / 8; i++)
150                         p[i] = bswap_64(p[i]);
151         }
152         return buf;
153 }
154
155 /* Return first non-zero offset in num offset array, or num. */
156 /* FIXME: Return the off? */
157 uint64_t tdb_find_nonzero_off(struct tdb_context *tdb, tdb_off_t off,
158                               uint64_t num)
159 {
160         uint64_t i, *val;
161         bool alloc = false;
162
163         val = tdb_direct(tdb, off, num * sizeof(tdb_off_t));
164         if (!unlikely(val)) {
165                 val = tdb_alloc_read(tdb, off, num * sizeof(tdb_off_t));
166                 if (!val)
167                         return num;
168                 alloc = true;
169         }
170
171         for (i = 0; i < num; i++) {
172                 if (val[i])
173                         break;
174         }
175         if (unlikely(alloc))
176                 free(val);
177         return i;
178 }
179
180 /* Return first zero offset in num offset array, or num. */
181 uint64_t tdb_find_zero_off(struct tdb_context *tdb, tdb_off_t off,
182                            uint64_t num)
183 {
184         uint64_t i, *val;
185         bool alloc = false;
186
187         val = tdb_direct(tdb, off, num * sizeof(tdb_off_t));
188         if (!unlikely(val)) {
189                 val = tdb_alloc_read(tdb, off, num * sizeof(tdb_off_t));
190                 if (!val)
191                         return num;
192                 alloc = true;
193         }
194
195         for (i = 0; i < num; i++) {
196                 if (!val[i])
197                         break;
198         }
199         if (unlikely(alloc))
200                 free(val);
201         return i;
202 }
203
204 static int fill(struct tdb_context *tdb,
205                 const void *buf, size_t size,
206                 tdb_off_t off, tdb_len_t len)
207 {
208         while (len) {
209                 size_t n = len > size ? size : len;
210
211                 if (!tdb_pwrite_all(tdb->fd, buf, n, off)) {
212                         tdb->ecode = TDB_ERR_IO;
213                         tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
214                                  "fill write failed: giving up!\n");
215                         return -1;
216                 }
217                 len -= n;
218                 off += n;
219         }
220         return 0;
221 }
222
223 int zero_out(struct tdb_context *tdb, tdb_off_t off, tdb_len_t len)
224 {
225         void *p = tdb_direct(tdb, off, len);
226         if (p) {
227                 memset(p, 0, len);
228                 return 0;
229         } else {
230                 char buf[8192] = { 0 };
231                 return fill(tdb, buf, sizeof(buf), off, len);
232         }
233 }
234
235 tdb_off_t tdb_read_off(struct tdb_context *tdb, tdb_off_t off)
236 {
237         tdb_off_t pad, *ret;
238
239         ret = tdb_get(tdb, off, &pad, sizeof(pad));
240         if (!ret) {
241                 return TDB_OFF_ERR;
242         }
243         return *ret;
244 }
245
246 /* Even on files, we can get partial writes due to signals. */
247 bool tdb_pwrite_all(int fd, const void *buf, size_t len, tdb_off_t off)
248 {
249         while (len) {
250                 ssize_t ret;
251                 ret = pwrite(fd, buf, len, off);
252                 if (ret < 0)
253                         return false;
254                 if (ret == 0) {
255                         errno = ENOSPC;
256                         return false;
257                 }
258                 buf = (char *)buf + ret;
259                 off += ret;
260                 len -= ret;
261         }
262         return true;
263 }
264
265 /* Even on files, we can get partial reads due to signals. */
266 bool tdb_pread_all(int fd, void *buf, size_t len, tdb_off_t off)
267 {
268         while (len) {
269                 ssize_t ret;
270                 ret = pread(fd, buf, len, off);
271                 if (ret < 0)
272                         return false;
273                 if (ret == 0) {
274                         /* ETOOSHORT? */
275                         errno = EWOULDBLOCK;
276                         return false;
277                 }
278                 buf = (char *)buf + ret;
279                 off += ret;
280                 len -= ret;
281         }
282         return true;
283 }
284
285 bool tdb_read_all(int fd, void *buf, size_t len)
286 {
287         while (len) {
288                 ssize_t ret;
289                 ret = read(fd, buf, len);
290                 if (ret < 0)
291                         return false;
292                 if (ret == 0) {
293                         /* ETOOSHORT? */
294                         errno = EWOULDBLOCK;
295                         return false;
296                 }
297                 buf = (char *)buf + ret;
298                 len -= ret;
299         }
300         return true;
301 }
302
303 /* write a lump of data at a specified offset */
304 static int tdb_write(struct tdb_context *tdb, tdb_off_t off, 
305                      const void *buf, tdb_len_t len)
306 {
307         if (len == 0) {
308                 return 0;
309         }
310
311         if (tdb->read_only) {
312                 tdb->ecode = TDB_ERR_RDONLY;
313                 return -1;
314         }
315
316         if (tdb->methods->oob(tdb, off + len, 0) != 0)
317                 return -1;
318
319         if (tdb->map_ptr) {
320                 memcpy(off + (char *)tdb->map_ptr, buf, len);
321         } else {
322                 if (!tdb_pwrite_all(tdb->fd, buf, len, off)) {
323                         tdb->ecode = TDB_ERR_IO;
324                         tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
325                                  "tdb_write failed at %llu len=%llu (%s)\n",
326                                  off, len, strerror(errno));
327                         return -1;
328                 }
329         }
330         return 0;
331 }
332
333 /* read a lump of data at a specified offset */
334 static int tdb_read(struct tdb_context *tdb, tdb_off_t off, void *buf,
335                     tdb_len_t len)
336 {
337         if (tdb->methods->oob(tdb, off + len, 0) != 0) {
338                 return -1;
339         }
340
341         if (tdb->map_ptr) {
342                 memcpy(buf, off + (char *)tdb->map_ptr, len);
343         } else {
344                 if (!tdb_pread_all(tdb->fd, buf, len, off)) {
345                         /* Ensure ecode is set for log fn. */
346                         tdb->ecode = TDB_ERR_IO;
347                         tdb->log(tdb, TDB_DEBUG_FATAL, tdb->log_priv,
348                                  "tdb_read failed at %lld "
349                                  "len=%lld (%s) map_size=%lld\n",
350                                  (long long)off, (long long)len,
351                                  strerror(errno),
352                                  (long long)tdb->map_size);
353                         return -1;
354                 }
355         }
356         return 0;
357 }
358
359 int tdb_write_convert(struct tdb_context *tdb, tdb_off_t off,
360                       void *rec, size_t len)
361 {
362         return tdb->methods->write(tdb, off, tdb_convert(tdb, rec, len), len);
363 }
364
365 int tdb_read_convert(struct tdb_context *tdb, tdb_off_t off,
366                       void *rec, size_t len)
367 {
368         int ret = tdb->methods->read(tdb, off, rec, len);
369         tdb_convert(tdb, rec, len);
370         return ret;
371 }
372
373 int tdb_write_off(struct tdb_context *tdb, tdb_off_t off, tdb_off_t val)
374 {
375         return tdb_write_convert(tdb, off, &val, sizeof(val));
376 }
377
378 /* read a lump of data, allocating the space for it */
379 void *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
380 {
381         void *buf;
382
383         /* some systems don't like zero length malloc */
384         buf = malloc(len ? len : 1);
385         if (unlikely(!buf)) {
386                 tdb->ecode = TDB_ERR_OOM;
387                 tdb->log(tdb, TDB_DEBUG_ERROR, tdb->log_priv,
388                          "tdb_alloc_read malloc failed len=%lld\n",
389                          (long long)len);
390         } else if (unlikely(tdb->methods->read(tdb, offset, buf, len))) {
391                 free(buf);
392                 buf = NULL;
393         }
394         return buf;
395 }
396
397 uint64_t hash_record(struct tdb_context *tdb, tdb_off_t off)
398 {
399         struct tdb_used_record pad, *r;
400         void *key;
401         uint64_t klen, hash;
402
403         r = tdb_get(tdb, off, &pad, sizeof(pad));
404         if (!r)
405                 /* FIXME */
406                 return 0;
407
408         klen = rec_key_length(r);
409         key = tdb_direct(tdb, off + sizeof(pad), klen);
410         if (likely(key))
411                 return tdb_hash(tdb, key, klen);
412
413         key = tdb_alloc_read(tdb, off + sizeof(pad), klen);
414         if (unlikely(!key))
415                 return 0;
416         hash = tdb_hash(tdb, key, klen);
417         free(key);
418         return hash;
419 }
420
421 /* Give a piece of tdb data to a parser */
422 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
423                    tdb_off_t offset, tdb_len_t len,
424                    int (*parser)(TDB_DATA key, TDB_DATA data,
425                                  void *private_data),
426                    void *private_data)
427 {
428         TDB_DATA data;
429         int result;
430         bool allocated = false;
431
432         data.dsize = len;
433         data.dptr = tdb_direct(tdb, offset, len);
434         if (unlikely(!data.dptr)) {
435                 if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
436                         return -1;
437                 }
438                 allocated = true;
439         }
440         result = parser(key, data, private_data);
441         if (unlikely(allocated))
442                 free(data.dptr);
443         return result;
444 }
445
446 /* expand a file.  we prefer to use ftruncate, as that is what posix
447   says to use for mmap expansion */
448 static int tdb_expand_file(struct tdb_context *tdb, tdb_len_t addition)
449 {
450         char buf[8192];
451
452         if (tdb->read_only) {
453                 tdb->ecode = TDB_ERR_RDONLY;
454                 return -1;
455         }
456
457         if (tdb->flags & TDB_INTERNAL) {
458                 char *new = realloc(tdb->map_ptr, tdb->map_size + addition);
459                 if (!new) {
460                         tdb->ecode = TDB_ERR_OOM;
461                         return -1;
462                 }
463                 tdb->map_ptr = new;
464                 tdb->map_size += addition;
465         } else {
466                 /* Unmap before trying to write; old TDB claimed OpenBSD had
467                  * problem with this otherwise. */
468                 tdb_munmap(tdb);
469
470                 /* If this fails, we try to fill anyway. */
471                 if (ftruncate(tdb->fd, tdb->map_size + addition))
472                         ;
473
474                 /* now fill the file with something. This ensures that the
475                    file isn't sparse, which would be very bad if we ran out of
476                    disk. This must be done with write, not via mmap */
477                 memset(buf, 0x43, sizeof(buf));
478                 if (fill(tdb, buf, sizeof(buf), tdb->map_size, addition) == -1)
479                         return -1;
480                 tdb->map_size += addition;
481                 tdb_mmap(tdb);
482         }
483         return 0;
484 }
485
486 const void *tdb_access_read(struct tdb_context *tdb,
487                             tdb_off_t off, tdb_len_t len)
488 {
489         const void *ret = tdb_direct(tdb, off, len);
490
491         if (!ret)
492                 ret = tdb_alloc_read(tdb, off, len);
493         return ret;
494 }
495
496 void tdb_access_release(struct tdb_context *tdb, const void *p)
497 {
498         if (!tdb->map_ptr
499             || (char *)p < (char *)tdb->map_ptr
500             || (char *)p >= (char *)tdb->map_ptr + tdb->map_size)
501                 free((void *)p);
502 }
503
504 #if 0
505 /* write a lump of data at a specified offset */
506 static int tdb_write(struct tdb_context *tdb, tdb_off_t off, 
507                      const void *buf, tdb_len_t len)
508 {
509         if (len == 0) {
510                 return 0;
511         }
512
513         if (tdb->read_only || tdb->traverse_read) {
514                 tdb->ecode = TDB_ERR_RDONLY;
515                 return -1;
516         }
517
518         if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
519                 return -1;
520
521         if (tdb->map_ptr) {
522                 memcpy(off + (char *)tdb->map_ptr, buf, len);
523         } else {
524                 ssize_t written = pwrite(tdb->fd, buf, len, off);
525                 if ((written != (ssize_t)len) && (written != -1)) {
526                         /* try once more */
527                         tdb->ecode = TDB_ERR_IO;
528                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
529                                  "%d of %d bytes at %d, trying once more\n",
530                                  (int)written, len, off));
531                         written = pwrite(tdb->fd, (const char *)buf+written,
532                                          len-written,
533                                          off+written);
534                 }
535                 if (written == -1) {
536                         /* Ensure ecode is set for log fn. */
537                         tdb->ecode = TDB_ERR_IO;
538                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
539                                  "len=%d (%s)\n", off, len, strerror(errno)));
540                         return -1;
541                 } else if (written != (ssize_t)len) {
542                         tdb->ecode = TDB_ERR_IO;
543                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
544                                  "write %d bytes at %d in two attempts\n",
545                                  len, off));
546                         return -1;
547                 }
548         }
549         return 0;
550 }
551
552
553
554 /*
555   do an unlocked scan of the hash table heads to find the next non-zero head. The value
556   will then be confirmed with the lock held
557 */              
558 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
559 {
560         uint32_t h = *chain;
561         if (tdb->map_ptr) {
562                 for (;h < tdb->header.hash_size;h++) {
563                         if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
564                                 break;
565                         }
566                 }
567         } else {
568                 uint32_t off=0;
569                 for (;h < tdb->header.hash_size;h++) {
570                         if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
571                                 break;
572                         }
573                 }
574         }
575         (*chain) = h;
576 }
577
578 /* read/write a tdb_off_t */
579 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
580 {
581         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
582 }
583
584 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
585 {
586         tdb_off_t off = *d;
587         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
588 }
589
590
591 /* read/write a record */
592 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
593 {
594         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
595                 return -1;
596         if (TDB_BAD_MAGIC(rec)) {
597                 /* Ensure ecode is set for log fn. */
598                 tdb->ecode = TDB_ERR_CORRUPT;
599                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
600                 return -1;
601         }
602         return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
603 }
604
605 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
606 {
607         struct tdb_record r = *rec;
608         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
609 }
610 #endif
611
612 static const struct tdb_methods io_methods = {
613         tdb_read,
614         tdb_write,
615         tdb_oob,
616         tdb_expand_file,
617 };
618
619 /*
620   initialise the default methods table
621 */
622 void tdb_io_init(struct tdb_context *tdb)
623 {
624         tdb->methods = &io_methods;
625 }