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