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