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