9572e7412eccc4d6f3666c6ab11d786f7c08e91e
[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), len, off);
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,
449                            tdb_len_t size, tdb_len_t addition)
450 {
451         char buf[8192];
452
453         if (tdb->read_only) {
454                 tdb->ecode = TDB_ERR_RDONLY;
455                 return -1;
456         }
457
458         /* If this fails, we try to fill anyway. */
459         if (ftruncate(tdb->fd, size+addition))
460                 ;
461
462         /* now fill the file with something. This ensures that the
463            file isn't sparse, which would be very bad if we ran out of
464            disk. This must be done with write, not via mmap */
465         memset(buf, 0x43, sizeof(buf));
466         return fill(tdb, buf, sizeof(buf), addition, size);
467 }
468
469 const void *tdb_access_read(struct tdb_context *tdb,
470                             tdb_off_t off, tdb_len_t len)
471 {
472         const void *ret = tdb_direct(tdb, off, len);
473
474         if (!ret)
475                 ret = tdb_alloc_read(tdb, off, len);
476         return ret;
477 }
478
479 void tdb_access_release(struct tdb_context *tdb, const void *p)
480 {
481         if (!tdb->map_ptr
482             || (char *)p < (char *)tdb->map_ptr
483             || (char *)p >= (char *)tdb->map_ptr + tdb->map_size)
484                 free((void *)p);
485 }
486
487 #if 0
488 /* write a lump of data at a specified offset */
489 static int tdb_write(struct tdb_context *tdb, tdb_off_t off, 
490                      const void *buf, tdb_len_t len)
491 {
492         if (len == 0) {
493                 return 0;
494         }
495
496         if (tdb->read_only || tdb->traverse_read) {
497                 tdb->ecode = TDB_ERR_RDONLY;
498                 return -1;
499         }
500
501         if (tdb->methods->tdb_oob(tdb, off + len, 0) != 0)
502                 return -1;
503
504         if (tdb->map_ptr) {
505                 memcpy(off + (char *)tdb->map_ptr, buf, len);
506         } else {
507                 ssize_t written = pwrite(tdb->fd, buf, len, off);
508                 if ((written != (ssize_t)len) && (written != -1)) {
509                         /* try once more */
510                         tdb->ecode = TDB_ERR_IO;
511                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: wrote only "
512                                  "%d of %d bytes at %d, trying once more\n",
513                                  (int)written, len, off));
514                         written = pwrite(tdb->fd, (const char *)buf+written,
515                                          len-written,
516                                          off+written);
517                 }
518                 if (written == -1) {
519                         /* Ensure ecode is set for log fn. */
520                         tdb->ecode = TDB_ERR_IO;
521                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_write failed at %d "
522                                  "len=%d (%s)\n", off, len, strerror(errno)));
523                         return -1;
524                 } else if (written != (ssize_t)len) {
525                         tdb->ecode = TDB_ERR_IO;
526                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_write: failed to "
527                                  "write %d bytes at %d in two attempts\n",
528                                  len, off));
529                         return -1;
530                 }
531         }
532         return 0;
533 }
534
535
536
537 /*
538   do an unlocked scan of the hash table heads to find the next non-zero head. The value
539   will then be confirmed with the lock held
540 */              
541 static void tdb_next_hash_chain(struct tdb_context *tdb, uint32_t *chain)
542 {
543         uint32_t h = *chain;
544         if (tdb->map_ptr) {
545                 for (;h < tdb->header.hash_size;h++) {
546                         if (0 != *(uint32_t *)(TDB_HASH_TOP(h) + (unsigned char *)tdb->map_ptr)) {
547                                 break;
548                         }
549                 }
550         } else {
551                 uint32_t off=0;
552                 for (;h < tdb->header.hash_size;h++) {
553                         if (tdb_ofs_read(tdb, TDB_HASH_TOP(h), &off) != 0 || off != 0) {
554                                 break;
555                         }
556                 }
557         }
558         (*chain) = h;
559 }
560
561
562 /* expand the database by expanding the underlying file and doing the
563    mmap again if necessary */
564 int tdb_expand(struct tdb_context *tdb)
565 {
566         struct tdb_record rec;
567         tdb_off_t offset, new_size;     
568
569         /* We have to lock every hash bucket and every free list. */
570         do {
571                 
572
573         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
574                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
575                 return -1;
576         }
577
578         /* must know about any previous expansions by another process */
579         tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
580
581         /* always make room for at least 100 more records, and at
582            least 25% more space. Round the database up to a multiple
583            of the page size */
584         new_size = MAX(tdb->map_size + size*100, tdb->map_size * 1.25);
585         size = TDB_ALIGN(new_size, tdb->page_size) - tdb->map_size;
586
587         if (!(tdb->flags & TDB_INTERNAL))
588                 tdb_munmap(tdb);
589
590         /*
591          * We must ensure the file is unmapped before doing this
592          * to ensure consistency with systems like OpenBSD where
593          * writes and mmaps are not consistent.
594          */
595
596         /* expand the file itself */
597         if (!(tdb->flags & TDB_INTERNAL)) {
598                 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
599                         goto fail;
600         }
601
602         tdb->map_size += size;
603
604         if (tdb->flags & TDB_INTERNAL) {
605                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
606                                                     tdb->map_size);
607                 if (!new_map_ptr) {
608                         tdb->map_size -= size;
609                         goto fail;
610                 }
611                 tdb->map_ptr = new_map_ptr;
612         } else {
613                 /*
614                  * We must ensure the file is remapped before adding the space
615                  * to ensure consistency with systems like OpenBSD where
616                  * writes and mmaps are not consistent.
617                  */
618
619                 /* We're ok if the mmap fails as we'll fallback to read/write */
620                 tdb_mmap(tdb);
621         }
622
623         /* form a new freelist record */
624         memset(&rec,'\0',sizeof(rec));
625         rec.rec_len = size - sizeof(rec);
626
627         /* link it into the free list */
628         offset = tdb->map_size - size;
629         if (tdb_free(tdb, offset, &rec) == -1)
630                 goto fail;
631
632         tdb_unlock(tdb, -1, F_WRLCK);
633         return 0;
634  fail:
635         tdb_unlock(tdb, -1, F_WRLCK);
636         return -1;
637 }
638
639 /* read/write a tdb_off_t */
640 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
641 {
642         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
643 }
644
645 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
646 {
647         tdb_off_t off = *d;
648         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
649 }
650
651
652 /* read/write a record */
653 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
654 {
655         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
656                 return -1;
657         if (TDB_BAD_MAGIC(rec)) {
658                 /* Ensure ecode is set for log fn. */
659                 tdb->ecode = TDB_ERR_CORRUPT;
660                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
661                 return -1;
662         }
663         return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
664 }
665
666 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct tdb_record *rec)
667 {
668         struct tdb_record r = *rec;
669         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
670 }
671 #endif
672
673 static const struct tdb_methods io_methods = {
674         tdb_read,
675         tdb_write,
676         tdb_oob,
677         tdb_expand_file,
678 };
679
680 /*
681   initialise the default methods table
682 */
683 void tdb_io_init(struct tdb_context *tdb)
684 {
685         tdb->methods = &io_methods;
686 }