source/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                 int n = addition>sizeof(buf)?sizeof(buf):addition;
 236                 int ret = pwrite(tdb->fd, buf, n, size);
 237                 if (ret != n) {
 238                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "expand_file write of %d failed (%s)\n",
 239                                    n, strerror(errno)));
 240                         return -1;
 241                 }
 242                 addition -= n;
 243                 size += n;
 244         }
 245         return 0;
 246 }
 247
 248
 249 /* expand the database at least size bytes by expanding the underlying
 250    file and doing the mmap again if necessary */
 251 int tdb_expand(struct tdb_context *tdb, tdb_off_t size)
 252 {
 253         struct list_struct rec;
 254         tdb_off_t offset;
 255
 256         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 257                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "lock failed in tdb_expand\n"));
 258                 return -1;
 259         }
 260
 261         /* must know about any previous expansions by another process */
 262         tdb->methods->tdb_oob(tdb, tdb->map_size + 1, 1);
 263
 264         /* always make room for at least 10 more records, and round
 265            the database up to a multiple of the page size */
 266         size = TDB_ALIGN(tdb->map_size + size*10, tdb->page_size) - tdb->map_size;
 267
 268         if (!(tdb->flags & TDB_INTERNAL))
 269                 tdb_munmap(tdb);
 270
 271         /*
 272          * We must ensure the file is unmapped before doing this
 273          * to ensure consistency with systems like OpenBSD where
 274          * writes and mmaps are not consistent.
 275          */
 276
 277         /* expand the file itself */
 278         if (!(tdb->flags & TDB_INTERNAL)) {
 279                 if (tdb->methods->tdb_expand_file(tdb, tdb->map_size, size) != 0)
 280                         goto fail;
 281         }
 282
 283         tdb->map_size += size;
 284
 285         if (tdb->flags & TDB_INTERNAL) {
 286                 char *new_map_ptr = (char *)realloc(tdb->map_ptr,
 287                                                     tdb->map_size);
 288                 if (!new_map_ptr) {
 289                         tdb->map_size -= size;
 290                         goto fail;
 291                 }
 292                 tdb->map_ptr = new_map_ptr;
 293         } else {
 294                 /*
 295                  * We must ensure the file is remapped before adding the space
 296                  * to ensure consistency with systems like OpenBSD where
 297                  * writes and mmaps are not consistent.
 298                  */
 299
 300                 /* We're ok if the mmap fails as we'll fallback to read/write */
 301                 tdb_mmap(tdb);
 302         }
 303
 304         /* form a new freelist record */
 305         memset(&rec,'\0',sizeof(rec));
 306         rec.rec_len = size - sizeof(rec);
 307
 308         /* link it into the free list */
 309         offset = tdb->map_size - size;
 310         if (tdb_free(tdb, offset, &rec) == -1)
 311                 goto fail;
 312
 313         tdb_unlock(tdb, -1, F_WRLCK);
 314         return 0;
 315  fail:
 316         tdb_unlock(tdb, -1, F_WRLCK);
 317         return -1;
 318 }
 319
 320 /* read/write a tdb_off_t */
 321 int tdb_ofs_read(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
 322 {
 323         return tdb->methods->tdb_read(tdb, offset, (char*)d, sizeof(*d), DOCONV());
 324 }
 325
 326 int tdb_ofs_write(struct tdb_context *tdb, tdb_off_t offset, tdb_off_t *d)
 327 {
 328         tdb_off_t off = *d;
 329         return tdb->methods->tdb_write(tdb, offset, CONVERT(off), sizeof(*d));
 330 }
 331
 332
 333 /* read a lump of data, allocating the space for it */
 334 unsigned char *tdb_alloc_read(struct tdb_context *tdb, tdb_off_t offset, tdb_len_t len)
 335 {
 336         unsigned char *buf;
 337
 338         /* some systems don't like zero length malloc */
 339         if (len == 0) {
 340                 len = 1;
 341         }
 342
 343         if (!(buf = (unsigned char *)malloc(len))) {
 344                 /* Ensure ecode is set for log fn. */
 345                 tdb->ecode = TDB_ERR_OOM;
 346                 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_alloc_read malloc failed len=%d (%s)\n",
 347                            len, strerror(errno)));
 348                 return TDB_ERRCODE(TDB_ERR_OOM, buf);
 349         }
 350         if (tdb->methods->tdb_read(tdb, offset, buf, len, 0) == -1) {
 351                 SAFE_FREE(buf);
 352                 return NULL;
 353         }
 354         return buf;
 355 }
 356
 357 /* Give a piece of tdb data to a parser */
 358
 359 int tdb_parse_data(struct tdb_context *tdb, TDB_DATA key,
 360                    tdb_off_t offset, tdb_len_t len,
 361                    int (*parser)(TDB_DATA key, TDB_DATA data,
 362                                  void *private_data),
 363                    void *private_data)
 364 {
 365         TDB_DATA data;
 366         int result;
 367
 368         data.dsize = len;
 369
 370         if ((tdb->transaction == NULL) && (tdb->map_ptr != NULL)) {
 371                 /*
 372                  * Optimize by avoiding the malloc/memcpy/free, point the
 373                  * parser directly at the mmap area.
 374                  */
 375                 if (tdb->methods->tdb_oob(tdb, offset+len, 0) != 0) {
 376                         return -1;
 377                 }
 378                 data.dptr = offset + (unsigned char *)tdb->map_ptr;
 379                 return parser(key, data, private_data);
 380         }
 381
 382         if (!(data.dptr = tdb_alloc_read(tdb, offset, len))) {
 383                 return -1;
 384         }
 385
 386         result = parser(key, data, private_data);
 387         free(data.dptr);
 388         return result;
 389 }
 390
 391 /* read/write a record */
 392 int tdb_rec_read(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
 393 {
 394         if (tdb->methods->tdb_read(tdb, offset, rec, sizeof(*rec),DOCONV()) == -1)
 395                 return -1;
 396         if (TDB_BAD_MAGIC(rec)) {
 397                 /* Ensure ecode is set for log fn. */
 398                 tdb->ecode = TDB_ERR_CORRUPT;
 399                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_rec_read bad magic 0x%x at offset=%d\n", rec->magic, offset));
 400                 return TDB_ERRCODE(TDB_ERR_CORRUPT, -1);
 401         }
 402         return tdb->methods->tdb_oob(tdb, rec->next+sizeof(*rec), 0);
 403 }
 404
 405 int tdb_rec_write(struct tdb_context *tdb, tdb_off_t offset, struct list_struct *rec)
 406 {
 407         struct list_struct r = *rec;
 408         return tdb->methods->tdb_write(tdb, offset, CONVERT(r), sizeof(r));
 409 }
 410
 411 static const struct tdb_methods io_methods = {
 412         tdb_read,
 413         tdb_write,
 414         tdb_next_hash_chain,
 415         tdb_oob,
 416         tdb_expand_file,
 417         tdb_brlock
 418 };
 419
 420 /*
 421   initialise the default methods table
 422 */
 423 void tdb_io_init(struct tdb_context *tdb)
 424 {
 425         tdb->methods = &io_methods;
 426 }