ntdb: hand correct error code when alloc_read allocation fails.
[kai/samba-autobuild/.git] / lib / ntdb / 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 ntdb
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 ntdb_munmap(struct ntdb_file *file)
32 {
33         if (file->fd == -1)
34                 return;
35
36         if (file->map_ptr) {
37                 munmap(file->map_ptr, file->map_size);
38                 file->map_ptr = NULL;
39         }
40 }
41
42 enum NTDB_ERROR ntdb_mmap(struct ntdb_context *ntdb)
43 {
44         int mmap_flags;
45
46         if (ntdb->flags & NTDB_INTERNAL)
47                 return NTDB_SUCCESS;
48
49 #ifndef HAVE_INCOHERENT_MMAP
50         if (ntdb->flags & NTDB_NOMMAP)
51                 return NTDB_SUCCESS;
52 #endif
53
54         if ((ntdb->open_flags & O_ACCMODE) == O_RDONLY)
55                 mmap_flags = PROT_READ;
56         else
57                 mmap_flags = PROT_READ | PROT_WRITE;
58
59         /* size_t can be smaller than off_t. */
60         if ((size_t)ntdb->file->map_size == ntdb->file->map_size) {
61                 ntdb->file->map_ptr = mmap(NULL, ntdb->file->map_size,
62                                           mmap_flags,
63                                           MAP_SHARED, ntdb->file->fd, 0);
64         } else
65                 ntdb->file->map_ptr = MAP_FAILED;
66
67         /*
68          * NB. When mmap fails it returns MAP_FAILED *NOT* NULL !!!!
69          */
70         if (ntdb->file->map_ptr == MAP_FAILED) {
71                 ntdb->file->map_ptr = NULL;
72 #ifdef HAVE_INCOHERENT_MMAP
73                 /* Incoherent mmap means everyone must mmap! */
74                 return ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
75                                   "ntdb_mmap failed for size %lld (%s)",
76                                   (long long)ntdb->file->map_size,
77                                   strerror(errno));
78 #else
79                 ntdb_logerr(ntdb, NTDB_SUCCESS, NTDB_LOG_WARNING,
80                            "ntdb_mmap failed for size %lld (%s)",
81                            (long long)ntdb->file->map_size, strerror(errno));
82 #endif
83         }
84         return NTDB_SUCCESS;
85 }
86
87 /* check for an out of bounds access - if it is out of bounds then
88    see if the database has been expanded by someone else and expand
89    if necessary
90    note that "len" is the minimum length needed for the db.
91
92    If probe is true, len being too large isn't a failure.
93 */
94 static enum NTDB_ERROR ntdb_normal_oob(struct ntdb_context *ntdb,
95                                        ntdb_off_t off, ntdb_len_t len,
96                                        bool probe)
97 {
98         struct stat st;
99         enum NTDB_ERROR ecode;
100
101         /* We can't hold pointers during this: we could unmap! */
102         assert(!ntdb->direct_access
103                || (ntdb->flags & NTDB_NOLOCK)
104                || ntdb_has_expansion_lock(ntdb));
105
106         if (len + off < len) {
107                 if (probe)
108                         return NTDB_SUCCESS;
109
110                 return ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
111                                   "ntdb_oob off %llu len %llu wrap\n",
112                                   (long long)off, (long long)len);
113         }
114
115         if (ntdb->flags & NTDB_INTERNAL) {
116                 if (probe)
117                         return NTDB_SUCCESS;
118
119                 ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
120                            "ntdb_oob len %lld beyond internal"
121                            " alloc size %lld",
122                            (long long)(off + len),
123                            (long long)ntdb->file->map_size);
124                 return NTDB_ERR_IO;
125         }
126
127         ecode = ntdb_lock_expand(ntdb, F_RDLCK);
128         if (ecode != NTDB_SUCCESS) {
129                 return ecode;
130         }
131
132         if (fstat(ntdb->file->fd, &st) != 0) {
133                 ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
134                            "Failed to fstat file: %s", strerror(errno));
135                 ntdb_unlock_expand(ntdb, F_RDLCK);
136                 return NTDB_ERR_IO;
137         }
138
139         ntdb_unlock_expand(ntdb, F_RDLCK);
140
141         if (st.st_size < off + len) {
142                 if (probe)
143                         return NTDB_SUCCESS;
144
145                 ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
146                            "ntdb_oob len %llu beyond eof at %llu",
147                            (long long)(off + len), (long long)st.st_size);
148                 return NTDB_ERR_IO;
149         }
150
151         /* Unmap, update size, remap */
152         ntdb_munmap(ntdb->file);
153
154         ntdb->file->map_size = st.st_size;
155         return ntdb_mmap(ntdb);
156 }
157
158 /* Endian conversion: we only ever deal with 8 byte quantities */
159 void *ntdb_convert(const struct ntdb_context *ntdb, void *buf, ntdb_len_t size)
160 {
161         assert(size % 8 == 0);
162         if (unlikely((ntdb->flags & NTDB_CONVERT)) && buf) {
163                 uint64_t i, *p = (uint64_t *)buf;
164                 for (i = 0; i < size / 8; i++)
165                         p[i] = bswap_64(p[i]);
166         }
167         return buf;
168 }
169
170 /* Return first non-zero offset in offset array, or end, or -ve error. */
171 /* FIXME: Return the off? */
172 uint64_t ntdb_find_nonzero_off(struct ntdb_context *ntdb,
173                               ntdb_off_t base, uint64_t start, uint64_t end)
174 {
175         uint64_t i;
176         const uint64_t *val;
177
178         /* Zero vs non-zero is the same unconverted: minor optimization. */
179         val = ntdb_access_read(ntdb, base + start * sizeof(ntdb_off_t),
180                               (end - start) * sizeof(ntdb_off_t), false);
181         if (NTDB_PTR_IS_ERR(val)) {
182                 return NTDB_ERR_TO_OFF(NTDB_PTR_ERR(val));
183         }
184
185         for (i = 0; i < (end - start); i++) {
186                 if (val[i])
187                         break;
188         }
189         ntdb_access_release(ntdb, val);
190         return start + i;
191 }
192
193 /* Return first zero offset in num offset array, or num, or -ve error. */
194 uint64_t ntdb_find_zero_off(struct ntdb_context *ntdb, ntdb_off_t off,
195                            uint64_t num)
196 {
197         uint64_t i;
198         const uint64_t *val;
199
200         /* Zero vs non-zero is the same unconverted: minor optimization. */
201         val = ntdb_access_read(ntdb, off, num * sizeof(ntdb_off_t), false);
202         if (NTDB_PTR_IS_ERR(val)) {
203                 return NTDB_ERR_TO_OFF(NTDB_PTR_ERR(val));
204         }
205
206         for (i = 0; i < num; i++) {
207                 if (!val[i])
208                         break;
209         }
210         ntdb_access_release(ntdb, val);
211         return i;
212 }
213
214 enum NTDB_ERROR zero_out(struct ntdb_context *ntdb, ntdb_off_t off, ntdb_len_t len)
215 {
216         char buf[8192] = { 0 };
217         void *p = ntdb->io->direct(ntdb, off, len, true);
218         enum NTDB_ERROR ecode = NTDB_SUCCESS;
219
220         assert(!(ntdb->flags & NTDB_RDONLY));
221         if (NTDB_PTR_IS_ERR(p)) {
222                 return NTDB_PTR_ERR(p);
223         }
224         if (p) {
225                 memset(p, 0, len);
226                 return ecode;
227         }
228         while (len) {
229                 unsigned todo = len < sizeof(buf) ? len : sizeof(buf);
230                 ecode = ntdb->io->twrite(ntdb, off, buf, todo);
231                 if (ecode != NTDB_SUCCESS) {
232                         break;
233                 }
234                 len -= todo;
235                 off += todo;
236         }
237         return ecode;
238 }
239
240 /* write a lump of data at a specified offset */
241 static enum NTDB_ERROR ntdb_write(struct ntdb_context *ntdb, ntdb_off_t off,
242                                 const void *buf, ntdb_len_t len)
243 {
244         enum NTDB_ERROR ecode;
245
246         if (ntdb->flags & NTDB_RDONLY) {
247                 return ntdb_logerr(ntdb, NTDB_ERR_RDONLY, NTDB_LOG_USE_ERROR,
248                                   "Write to read-only database");
249         }
250
251         ecode = ntdb_oob(ntdb, off, len, false);
252         if (ecode != NTDB_SUCCESS) {
253                 return ecode;
254         }
255
256         if (ntdb->file->map_ptr) {
257                 memcpy(off + (char *)ntdb->file->map_ptr, buf, len);
258         } else {
259 #ifdef HAVE_INCOHERENT_MMAP
260                 return NTDB_ERR_IO;
261 #else
262                 ssize_t ret;
263                 ret = pwrite(ntdb->file->fd, buf, len, off);
264                 if (ret != len) {
265                         /* This shouldn't happen: we avoid sparse files. */
266                         if (ret >= 0)
267                                 errno = ENOSPC;
268
269                         return ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
270                                           "ntdb_write: %zi at %zu len=%zu (%s)",
271                                           ret, (size_t)off, (size_t)len,
272                                           strerror(errno));
273                 }
274 #endif
275         }
276         return NTDB_SUCCESS;
277 }
278
279 /* read a lump of data at a specified offset */
280 static enum NTDB_ERROR ntdb_read(struct ntdb_context *ntdb, ntdb_off_t off,
281                                void *buf, ntdb_len_t len)
282 {
283         enum NTDB_ERROR ecode;
284
285         ecode = ntdb_oob(ntdb, off, len, false);
286         if (ecode != NTDB_SUCCESS) {
287                 return ecode;
288         }
289
290         if (ntdb->file->map_ptr) {
291                 memcpy(buf, off + (char *)ntdb->file->map_ptr, len);
292         } else {
293 #ifdef HAVE_INCOHERENT_MMAP
294                 return NTDB_ERR_IO;
295 #else
296                 ssize_t r = pread(ntdb->file->fd, buf, len, off);
297                 if (r != len) {
298                         return ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
299                                           "ntdb_read failed with %zi at %zu "
300                                           "len=%zu (%s) map_size=%zu",
301                                           r, (size_t)off, (size_t)len,
302                                           strerror(errno),
303                                           (size_t)ntdb->file->map_size);
304                 }
305 #endif
306         }
307         return NTDB_SUCCESS;
308 }
309
310 enum NTDB_ERROR ntdb_write_convert(struct ntdb_context *ntdb, ntdb_off_t off,
311                                  const void *rec, size_t len)
312 {
313         enum NTDB_ERROR ecode;
314
315         if (unlikely((ntdb->flags & NTDB_CONVERT))) {
316                 void *conv = ntdb->alloc_fn(ntdb, len, ntdb->alloc_data);
317                 if (!conv) {
318                         return ntdb_logerr(ntdb, NTDB_ERR_OOM, NTDB_LOG_ERROR,
319                                           "ntdb_write: no memory converting"
320                                           " %zu bytes", len);
321                 }
322                 memcpy(conv, rec, len);
323                 ecode = ntdb->io->twrite(ntdb, off,
324                                          ntdb_convert(ntdb, conv, len), len);
325                 ntdb->free_fn(conv, ntdb->alloc_data);
326         } else {
327                 ecode = ntdb->io->twrite(ntdb, off, rec, len);
328         }
329         return ecode;
330 }
331
332 enum NTDB_ERROR ntdb_read_convert(struct ntdb_context *ntdb, ntdb_off_t off,
333                                 void *rec, size_t len)
334 {
335         enum NTDB_ERROR ecode = ntdb->io->tread(ntdb, off, rec, len);
336         ntdb_convert(ntdb, rec, len);
337         return ecode;
338 }
339
340 static void *_ntdb_alloc_read(struct ntdb_context *ntdb, ntdb_off_t offset,
341                              ntdb_len_t len, unsigned int prefix)
342 {
343         unsigned char *buf;
344         enum NTDB_ERROR ecode;
345
346         /* some systems don't like zero length malloc */
347         buf = ntdb->alloc_fn(ntdb, prefix + len ? prefix + len : 1,
348                           ntdb->alloc_data);
349         if (!buf) {
350                 ntdb_logerr(ntdb, NTDB_ERR_OOM, NTDB_LOG_ERROR,
351                            "ntdb_alloc_read alloc failed len=%zu",
352                            (size_t)(prefix + len));
353                 return NTDB_ERR_PTR(NTDB_ERR_OOM);
354         } else {
355                 ecode = ntdb->io->tread(ntdb, offset, buf+prefix, len);
356                 if (unlikely(ecode != NTDB_SUCCESS)) {
357                         ntdb->free_fn(buf, ntdb->alloc_data);
358                         return NTDB_ERR_PTR(ecode);
359                 }
360         }
361         return buf;
362 }
363
364 /* read a lump of data, allocating the space for it */
365 void *ntdb_alloc_read(struct ntdb_context *ntdb, ntdb_off_t offset, ntdb_len_t len)
366 {
367         return _ntdb_alloc_read(ntdb, offset, len, 0);
368 }
369
370 static enum NTDB_ERROR fill(struct ntdb_context *ntdb,
371                            const void *buf, size_t size,
372                            ntdb_off_t off, ntdb_len_t len)
373 {
374         while (len) {
375                 size_t n = len > size ? size : len;
376                 ssize_t ret = pwrite(ntdb->file->fd, buf, n, off);
377                 if (ret != n) {
378                         if (ret >= 0)
379                                 errno = ENOSPC;
380
381                         return ntdb_logerr(ntdb, NTDB_ERR_IO, NTDB_LOG_ERROR,
382                                           "fill failed:"
383                                           " %zi at %zu len=%zu (%s)",
384                                           ret, (size_t)off, (size_t)len,
385                                           strerror(errno));
386                 }
387                 len -= n;
388                 off += n;
389         }
390         return NTDB_SUCCESS;
391 }
392
393 /* expand a file.  we prefer to use ftruncate, as that is what posix
394   says to use for mmap expansion */
395 static enum NTDB_ERROR ntdb_expand_file(struct ntdb_context *ntdb,
396                                       ntdb_len_t addition)
397 {
398         char buf[8192];
399         enum NTDB_ERROR ecode;
400
401         assert((ntdb->file->map_size + addition) % NTDB_PGSIZE == 0);
402         if (ntdb->flags & NTDB_RDONLY) {
403                 return ntdb_logerr(ntdb, NTDB_ERR_RDONLY, NTDB_LOG_USE_ERROR,
404                                   "Expand on read-only database");
405         }
406
407         if (ntdb->flags & NTDB_INTERNAL) {
408                 char *new = ntdb->expand_fn(ntdb->file->map_ptr,
409                                         ntdb->file->map_size + addition,
410                                         ntdb->alloc_data);
411                 if (!new) {
412                         return ntdb_logerr(ntdb, NTDB_ERR_OOM, NTDB_LOG_ERROR,
413                                           "No memory to expand database");
414                 }
415                 ntdb->file->map_ptr = new;
416                 ntdb->file->map_size += addition;
417                 return NTDB_SUCCESS;
418         } else {
419                 /* Unmap before trying to write; old NTDB claimed OpenBSD had
420                  * problem with this otherwise. */
421                 ntdb_munmap(ntdb->file);
422
423                 /* If this fails, we try to fill anyway. */
424                 if (ftruncate(ntdb->file->fd, ntdb->file->map_size + addition))
425                         ;
426
427                 /* now fill the file with something. This ensures that the
428                    file isn't sparse, which would be very bad if we ran out of
429                    disk. This must be done with write, not via mmap */
430                 memset(buf, 0x43, sizeof(buf));
431                 ecode = fill(ntdb, buf, sizeof(buf), ntdb->file->map_size,
432                              addition);
433                 if (ecode != NTDB_SUCCESS)
434                         return ecode;
435                 ntdb->file->map_size += addition;
436                 return ntdb_mmap(ntdb);
437         }
438 }
439
440 const void *ntdb_access_read(struct ntdb_context *ntdb,
441                             ntdb_off_t off, ntdb_len_t len, bool convert)
442 {
443         void *ret = NULL;
444
445         if (likely(!(ntdb->flags & NTDB_CONVERT))) {
446                 ret = ntdb->io->direct(ntdb, off, len, false);
447
448                 if (NTDB_PTR_IS_ERR(ret)) {
449                         return ret;
450                 }
451         }
452         if (!ret) {
453                 struct ntdb_access_hdr *hdr;
454                 hdr = _ntdb_alloc_read(ntdb, off, len, sizeof(*hdr));
455                 if (NTDB_PTR_IS_ERR(hdr)) {
456                         return hdr;
457                 }
458                 hdr->next = ntdb->access;
459                 ntdb->access = hdr;
460                 ret = hdr + 1;
461                 if (convert) {
462                         ntdb_convert(ntdb, (void *)ret, len);
463                 }
464         } else
465                 ntdb->direct_access++;
466
467         return ret;
468 }
469
470 void *ntdb_access_write(struct ntdb_context *ntdb,
471                        ntdb_off_t off, ntdb_len_t len, bool convert)
472 {
473         void *ret = NULL;
474
475         if (ntdb->flags & NTDB_RDONLY) {
476                 ntdb_logerr(ntdb, NTDB_ERR_RDONLY, NTDB_LOG_USE_ERROR,
477                            "Write to read-only database");
478                 return NTDB_ERR_PTR(NTDB_ERR_RDONLY);
479         }
480
481         if (likely(!(ntdb->flags & NTDB_CONVERT))) {
482                 ret = ntdb->io->direct(ntdb, off, len, true);
483
484                 if (NTDB_PTR_IS_ERR(ret)) {
485                         return ret;
486                 }
487         }
488
489         if (!ret) {
490                 struct ntdb_access_hdr *hdr;
491                 hdr = _ntdb_alloc_read(ntdb, off, len, sizeof(*hdr));
492                 if (NTDB_PTR_IS_ERR(hdr)) {
493                         return hdr;
494                 }
495                 hdr->next = ntdb->access;
496                 ntdb->access = hdr;
497                 hdr->off = off;
498                 hdr->len = len;
499                 hdr->convert = convert;
500                 ret = hdr + 1;
501                 if (convert)
502                         ntdb_convert(ntdb, (void *)ret, len);
503         } else
504                 ntdb->direct_access++;
505
506         return ret;
507 }
508
509 static struct ntdb_access_hdr **find_hdr(struct ntdb_context *ntdb, const void *p)
510 {
511         struct ntdb_access_hdr **hp;
512
513         for (hp = &ntdb->access; *hp; hp = &(*hp)->next) {
514                 if (*hp + 1 == p)
515                         return hp;
516         }
517         return NULL;
518 }
519
520 void ntdb_access_release(struct ntdb_context *ntdb, const void *p)
521 {
522         struct ntdb_access_hdr *hdr, **hp = find_hdr(ntdb, p);
523
524         if (hp) {
525                 hdr = *hp;
526                 *hp = hdr->next;
527                 ntdb->free_fn(hdr, ntdb->alloc_data);
528         } else
529                 ntdb->direct_access--;
530 }
531
532 enum NTDB_ERROR ntdb_access_commit(struct ntdb_context *ntdb, void *p)
533 {
534         struct ntdb_access_hdr *hdr, **hp = find_hdr(ntdb, p);
535         enum NTDB_ERROR ecode;
536
537         if (hp) {
538                 hdr = *hp;
539                 if (hdr->convert)
540                         ecode = ntdb_write_convert(ntdb, hdr->off, p, hdr->len);
541                 else
542                         ecode = ntdb_write(ntdb, hdr->off, p, hdr->len);
543                 *hp = hdr->next;
544                 ntdb->free_fn(hdr, ntdb->alloc_data);
545         } else {
546                 ntdb->direct_access--;
547                 ecode = NTDB_SUCCESS;
548         }
549
550         return ecode;
551 }
552
553 static void *ntdb_direct(struct ntdb_context *ntdb, ntdb_off_t off, size_t len,
554                         bool write_mode)
555 {
556         enum NTDB_ERROR ecode;
557
558         if (unlikely(!ntdb->file->map_ptr))
559                 return NULL;
560
561         ecode = ntdb_oob(ntdb, off, len, false);
562         if (unlikely(ecode != NTDB_SUCCESS))
563                 return NTDB_ERR_PTR(ecode);
564         return (char *)ntdb->file->map_ptr + off;
565 }
566
567 static ntdb_off_t ntdb_read_normal_off(struct ntdb_context *ntdb,
568                                        ntdb_off_t off)
569 {
570         ntdb_off_t ret;
571         enum NTDB_ERROR ecode;
572         ntdb_off_t *p;
573
574         p = ntdb_direct(ntdb, off, sizeof(*p), false);
575         if (NTDB_PTR_IS_ERR(p)) {
576                 return NTDB_ERR_TO_OFF(NTDB_PTR_ERR(p));
577         }
578         if (likely(p)) {
579                 return *p;
580         }
581
582         ecode = ntdb_read(ntdb, off, &ret, sizeof(ret));
583         if (ecode != NTDB_SUCCESS) {
584                 return NTDB_ERR_TO_OFF(ecode);
585         }
586         return ret;
587 }
588
589 static ntdb_off_t ntdb_read_convert_off(struct ntdb_context *ntdb,
590                                         ntdb_off_t off)
591 {
592         ntdb_off_t ret;
593         enum NTDB_ERROR ecode;
594
595         ecode = ntdb_read_convert(ntdb, off, &ret, sizeof(ret));
596         if (ecode != NTDB_SUCCESS) {
597                 return NTDB_ERR_TO_OFF(ecode);
598         }
599         return ret;
600 }
601
602 static enum NTDB_ERROR ntdb_write_normal_off(struct ntdb_context *ntdb,
603                                              ntdb_off_t off, ntdb_off_t val)
604 {
605         ntdb_off_t *p;
606
607         p = ntdb_direct(ntdb, off, sizeof(*p), true);
608         if (NTDB_PTR_IS_ERR(p)) {
609                 return NTDB_PTR_ERR(p);
610         }
611         if (likely(p)) {
612                 *p = val;
613                 return NTDB_SUCCESS;
614         }
615         return ntdb_write(ntdb, off, &val, sizeof(val));
616 }
617
618 static enum NTDB_ERROR ntdb_write_convert_off(struct ntdb_context *ntdb,
619                                               ntdb_off_t off, ntdb_off_t val)
620 {
621         return ntdb_write_convert(ntdb, off, &val, sizeof(val));
622 }
623
624 void ntdb_inc_seqnum(struct ntdb_context *ntdb)
625 {
626         ntdb_off_t seq;
627
628         if (likely(!(ntdb->flags & NTDB_CONVERT))) {
629                 int64_t *direct;
630
631                 direct = ntdb->io->direct(ntdb,
632                                          offsetof(struct ntdb_header, seqnum),
633                                          sizeof(*direct), true);
634                 if (likely(direct)) {
635                         /* Don't let it go negative, even briefly */
636                         if (unlikely((*direct) + 1) < 0)
637                                 *direct = 0;
638                         (*direct)++;
639                         return;
640                 }
641         }
642
643         seq = ntdb_read_off(ntdb, offsetof(struct ntdb_header, seqnum));
644         if (!NTDB_OFF_IS_ERR(seq)) {
645                 seq++;
646                 if (unlikely((int64_t)seq < 0))
647                         seq = 0;
648                 ntdb_write_off(ntdb, offsetof(struct ntdb_header, seqnum), seq);
649         }
650 }
651
652 static const struct ntdb_methods io_methods = {
653         ntdb_read,
654         ntdb_write,
655         ntdb_normal_oob,
656         ntdb_expand_file,
657         ntdb_direct,
658         ntdb_read_normal_off,
659         ntdb_write_normal_off,
660 };
661
662 static const struct ntdb_methods io_convert_methods = {
663         ntdb_read,
664         ntdb_write,
665         ntdb_normal_oob,
666         ntdb_expand_file,
667         ntdb_direct,
668         ntdb_read_convert_off,
669         ntdb_write_convert_off,
670 };
671
672 /*
673   initialise the default methods table
674 */
675 void ntdb_io_init(struct ntdb_context *ntdb)
676 {
677         if (ntdb->flags & NTDB_CONVERT)
678                 ntdb->io = &io_convert_methods;
679         else
680                 ntdb->io = &io_methods;
681 }