git.ozlabs.org Git - ccan/blob - ccan/tdb2/tdb1_tdb.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 "tdb1_private.h"
  29 #include <assert.h>
  30
  31 /*
  32   non-blocking increment of the tdb sequence number if the tdb has been opened using
  33   the TDB_SEQNUM flag
  34 */
  35 void tdb1_increment_seqnum_nonblock(struct tdb_context *tdb)
  36 {
  37         tdb1_off_t seqnum=0;
  38
  39         if (!(tdb->flags & TDB_SEQNUM)) {
  40                 return;
  41         }
  42
  43         /* we ignore errors from this, as we have no sane way of
  44            dealing with them.
  45         */
  46         tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
  47         seqnum++;
  48         tdb1_ofs_write(tdb, TDB1_SEQNUM_OFS, &seqnum);
  49 }
  50
  51 /*
  52   increment the tdb sequence number if the tdb has been opened using
  53   the TDB_SEQNUM flag
  54 */
  55 static void tdb1_increment_seqnum(struct tdb_context *tdb)
  56 {
  57         if (!(tdb->flags & TDB_SEQNUM)) {
  58                 return;
  59         }
  60
  61         if (tdb1_nest_lock(tdb, TDB1_SEQNUM_OFS, F_WRLCK,
  62                            TDB_LOCK_WAIT|TDB_LOCK_PROBE) != 0) {
  63                 return;
  64         }
  65
  66         tdb1_increment_seqnum_nonblock(tdb);
  67
  68         tdb1_nest_unlock(tdb, TDB1_SEQNUM_OFS, F_WRLCK);
  69 }
  70
  71 static int tdb1_key_compare(TDB_DATA key, TDB_DATA data, void *private_data)
  72 {
  73         return memcmp(data.dptr, key.dptr, data.dsize);
  74 }
  75
  76 /* Returns 0 on fail.  On success, return offset of record, and fills
  77    in rec */
  78 static tdb1_off_t tdb1_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
  79                         struct tdb1_record *r)
  80 {
  81         tdb1_off_t rec_ptr;
  82
  83         /* read in the hash top */
  84         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
  85                 return 0;
  86
  87         /* keep looking until we find the right record */
  88         while (rec_ptr) {
  89                 if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
  90                         return 0;
  91
  92                 tdb->stats.compares++;
  93                 if (TDB1_DEAD(r)) {
  94                         tdb->stats.compare_wrong_bucket++;
  95                 } else if (key.dsize != r->key_len) {
  96                         tdb->stats.compare_wrong_keylen++;
  97                 } else if (hash != r->full_hash) {
  98                         tdb->stats.compare_wrong_rechash++;
  99                 } else if (tdb1_parse_data(tdb, key, rec_ptr + sizeof(*r),
 100                                            r->key_len, tdb1_key_compare,
 101                                            NULL) != 0) {
 102                         tdb->stats.compare_wrong_keycmp++;
 103                 } else {
 104                         return rec_ptr;
 105                 }
 106                 /* detect tight infinite loop */
 107                 if (rec_ptr == r->next) {
 108                         tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT,
 109                                                 TDB_LOG_ERROR,
 110                                                 "tdb1_find: loop detected.");
 111                         return 0;
 112                 }
 113                 rec_ptr = r->next;
 114         }
 115         tdb->last_error = TDB_ERR_NOEXIST;
 116         return 0;
 117 }
 118
 119 /* As tdb1_find, but if you succeed, keep the lock */
 120 tdb1_off_t tdb1_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
 121                            struct tdb1_record *rec)
 122 {
 123         uint32_t rec_ptr;
 124
 125         if (tdb1_lock(tdb, TDB1_BUCKET(hash), locktype) == -1)
 126                 return 0;
 127         if (!(rec_ptr = tdb1_find(tdb, key, hash, rec)))
 128                 tdb1_unlock(tdb, TDB1_BUCKET(hash), locktype);
 129         return rec_ptr;
 130 }
 131
 132 static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key);
 133
 134 /* update an entry in place - this only works if the new data size
 135    is <= the old data size and the key exists.
 136    on failure return -1.
 137 */
 138 static int tdb1_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
 139 {
 140         struct tdb1_record rec;
 141         tdb1_off_t rec_ptr;
 142
 143         /* find entry */
 144         if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec)))
 145                 return -1;
 146
 147         /* it could be an exact duplicate of what is there - this is
 148          * surprisingly common (eg. with a ldb re-index). */
 149         if (rec.key_len == key.dsize &&
 150             rec.data_len == dbuf.dsize &&
 151             rec.full_hash == hash) {
 152                 TDB_DATA data = _tdb1_fetch(tdb, key);
 153                 if (data.dsize == dbuf.dsize &&
 154                     memcmp(data.dptr, dbuf.dptr, data.dsize) == 0) {
 155                         if (data.dptr) {
 156                                 free(data.dptr);
 157                         }
 158                         return 0;
 159                 }
 160                 if (data.dptr) {
 161                         free(data.dptr);
 162                 }
 163         }
 164
 165         /* must be long enough key, data and tailer */
 166         if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb1_off_t)) {
 167                 tdb->last_error = TDB_SUCCESS; /* Not really an error */
 168                 return -1;
 169         }
 170
 171         if (tdb->tdb1.io->tdb1_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 172                       dbuf.dptr, dbuf.dsize) == -1)
 173                 return -1;
 174
 175         if (dbuf.dsize != rec.data_len) {
 176                 /* update size */
 177                 rec.data_len = dbuf.dsize;
 178                 return tdb1_rec_write(tdb, rec_ptr, &rec);
 179         }
 180
 181         return 0;
 182 }
 183
 184 /* find an entry in the database given a key */
 185 /* If an entry doesn't exist tdb1_err will be set to
 186  * TDB_ERR_NOEXIST. If a key has no data attached
 187  * then the TDB_DATA will have zero length but
 188  * a non-zero pointer
 189  */
 190 static TDB_DATA _tdb1_fetch(struct tdb_context *tdb, TDB_DATA key)
 191 {
 192         tdb1_off_t rec_ptr;
 193         struct tdb1_record rec;
 194         TDB_DATA ret;
 195         uint32_t hash;
 196
 197         /* find which hash bucket it is in */
 198         hash = tdb_hash(tdb, key.dptr, key.dsize);
 199         if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 200                 ret.dptr = NULL;
 201                 ret.dsize = 0;
 202                 return ret;
 203         }
 204
 205         ret.dptr = tdb1_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 206                                   rec.data_len);
 207         ret.dsize = rec.data_len;
 208         tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
 209         return ret;
 210 }
 211
 212 enum TDB_ERROR tdb1_fetch(struct tdb_context *tdb, TDB_DATA key, TDB_DATA *data)
 213 {
 214         *data = _tdb1_fetch(tdb, key);
 215         if (data->dptr == NULL)
 216                 return tdb->last_error;
 217         return TDB_SUCCESS;
 218 }
 219
 220 enum TDB_ERROR tdb1_parse_record(struct tdb_context *tdb, TDB_DATA key,
 221                                  enum TDB_ERROR (*parser)(TDB_DATA key,
 222                                                           TDB_DATA data,
 223                                                           void *private_data),
 224                                  void *private_data)
 225 {
 226         tdb1_off_t rec_ptr;
 227         struct tdb1_record rec;
 228         enum TDB_ERROR ret;
 229         uint32_t hash;
 230
 231         /* find which hash bucket it is in */
 232         hash = tdb_hash(tdb, key.dptr, key.dsize);
 233
 234         if (!(rec_ptr = tdb1_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 235                 /* record not found */
 236                 return TDB_ERR_NOEXIST;
 237         }
 238
 239         ret = tdb1_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
 240                              rec.data_len, parser, private_data);
 241
 242         tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
 243
 244         return ret;
 245 }
 246
 247 /* check if an entry in the database exists
 248
 249    note that 1 is returned if the key is found and 0 is returned if not found
 250    this doesn't match the conventions in the rest of this module, but is
 251    compatible with gdbm
 252 */
 253 static int tdb1_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 254 {
 255         struct tdb1_record rec;
 256
 257         if (tdb1_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
 258                 return 0;
 259         tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_RDLCK);
 260         return 1;
 261 }
 262
 263 int tdb1_exists(struct tdb_context *tdb, TDB_DATA key)
 264 {
 265         uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
 266         int ret;
 267
 268         assert(tdb->flags & TDB_VERSION1);
 269         ret = tdb1_exists_hash(tdb, key, hash);
 270         return ret;
 271 }
 272
 273 /* actually delete an entry in the database given the offset */
 274 int tdb1_do_delete(struct tdb_context *tdb, tdb1_off_t rec_ptr, struct tdb1_record *rec)
 275 {
 276         tdb1_off_t last_ptr, i;
 277         struct tdb1_record lastrec;
 278
 279         if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) return -1;
 280
 281         if (((tdb->tdb1.traverse_write != 0) && (!TDB1_DEAD(rec))) ||
 282             tdb1_write_lock_record(tdb, rec_ptr) == -1) {
 283                 /* Someone traversing here: mark it as dead */
 284                 rec->magic = TDB1_DEAD_MAGIC;
 285                 return tdb1_rec_write(tdb, rec_ptr, rec);
 286         }
 287         if (tdb1_write_unlock_record(tdb, rec_ptr) != 0)
 288                 return -1;
 289
 290         /* find previous record in hash chain */
 291         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(rec->full_hash), &i) == -1)
 292                 return -1;
 293         for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
 294                 if (tdb1_rec_read(tdb, i, &lastrec) == -1)
 295                         return -1;
 296
 297         /* unlink it: next ptr is at start of record. */
 298         if (last_ptr == 0)
 299                 last_ptr = TDB1_HASH_TOP(rec->full_hash);
 300         if (tdb1_ofs_write(tdb, last_ptr, &rec->next) == -1)
 301                 return -1;
 302
 303         /* recover the space */
 304         if (tdb1_free(tdb, rec_ptr, rec) == -1)
 305                 return -1;
 306         return 0;
 307 }
 308
 309 static int tdb1_count_dead(struct tdb_context *tdb, uint32_t hash)
 310 {
 311         int res = 0;
 312         tdb1_off_t rec_ptr;
 313         struct tdb1_record rec;
 314
 315         /* read in the hash top */
 316         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
 317                 return 0;
 318
 319         while (rec_ptr) {
 320                 if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1)
 321                         return 0;
 322
 323                 if (rec.magic == TDB1_DEAD_MAGIC) {
 324                         res += 1;
 325                 }
 326                 rec_ptr = rec.next;
 327         }
 328         return res;
 329 }
 330
 331 /*
 332  * Purge all DEAD records from a hash chain
 333  */
 334 static int tdb1_purge_dead(struct tdb_context *tdb, uint32_t hash)
 335 {
 336         int res = -1;
 337         struct tdb1_record rec;
 338         tdb1_off_t rec_ptr;
 339
 340         if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
 341                 return -1;
 342         }
 343
 344         /* read in the hash top */
 345         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
 346                 goto fail;
 347
 348         while (rec_ptr) {
 349                 tdb1_off_t next;
 350
 351                 if (tdb1_rec_read(tdb, rec_ptr, &rec) == -1) {
 352                         goto fail;
 353                 }
 354
 355                 next = rec.next;
 356
 357                 if (rec.magic == TDB1_DEAD_MAGIC
 358                     && tdb1_do_delete(tdb, rec_ptr, &rec) == -1) {
 359                         goto fail;
 360                 }
 361                 rec_ptr = next;
 362         }
 363         res = 0;
 364  fail:
 365         tdb1_unlock(tdb, -1, F_WRLCK);
 366         return res;
 367 }
 368
 369 /* delete an entry in the database given a key */
 370 static int tdb1_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 371 {
 372         tdb1_off_t rec_ptr;
 373         struct tdb1_record rec;
 374         int ret;
 375
 376         if (tdb->tdb1.max_dead_records != 0) {
 377
 378                 /*
 379                  * Allow for some dead records per hash chain, mainly for
 380                  * tdb's with a very high create/delete rate like locking.tdb.
 381                  */
 382
 383                 if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
 384                         return -1;
 385
 386                 if (tdb1_count_dead(tdb, hash) >= tdb->tdb1.max_dead_records) {
 387                         /*
 388                          * Don't let the per-chain freelist grow too large,
 389                          * delete all existing dead records
 390                          */
 391                         tdb1_purge_dead(tdb, hash);
 392                 }
 393
 394                 if (!(rec_ptr = tdb1_find(tdb, key, hash, &rec))) {
 395                         tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
 396                         return -1;
 397                 }
 398
 399                 /*
 400                  * Just mark the record as dead.
 401                  */
 402                 rec.magic = TDB1_DEAD_MAGIC;
 403                 ret = tdb1_rec_write(tdb, rec_ptr, &rec);
 404         }
 405         else {
 406                 if (!(rec_ptr = tdb1_find_lock_hash(tdb, key, hash, F_WRLCK,
 407                                                    &rec)))
 408                         return -1;
 409
 410                 ret = tdb1_do_delete(tdb, rec_ptr, &rec);
 411         }
 412
 413         if (ret == 0) {
 414                 tdb1_increment_seqnum(tdb);
 415         }
 416
 417         if (tdb1_unlock(tdb, TDB1_BUCKET(rec.full_hash), F_WRLCK) != 0)
 418                 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 419                            "tdb1_delete: WARNING tdb1_unlock failed!");
 420         return ret;
 421 }
 422
 423 int tdb1_delete(struct tdb_context *tdb, TDB_DATA key)
 424 {
 425         uint32_t hash = tdb_hash(tdb, key.dptr, key.dsize);
 426         int ret;
 427
 428         assert(tdb->flags & TDB_VERSION1);
 429         ret = tdb1_delete_hash(tdb, key, hash);
 430         return ret;
 431 }
 432
 433 /*
 434  * See if we have a dead record around with enough space
 435  */
 436 static tdb1_off_t tdb1_find_dead(struct tdb_context *tdb, uint32_t hash,
 437                                struct tdb1_record *r, tdb1_len_t length)
 438 {
 439         tdb1_off_t rec_ptr;
 440
 441         /* read in the hash top */
 442         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1)
 443                 return 0;
 444
 445         /* keep looking until we find the right record */
 446         while (rec_ptr) {
 447                 if (tdb1_rec_read(tdb, rec_ptr, r) == -1)
 448                         return 0;
 449
 450                 if (TDB1_DEAD(r) && r->rec_len >= length) {
 451                         /*
 452                          * First fit for simple coding, TODO: change to best
 453                          * fit
 454                          */
 455                         return rec_ptr;
 456                 }
 457                 rec_ptr = r->next;
 458         }
 459         return 0;
 460 }
 461
 462 static int _tdb1_store(struct tdb_context *tdb, TDB_DATA key,
 463                        TDB_DATA dbuf, int flag, uint32_t hash)
 464 {
 465         struct tdb1_record rec;
 466         tdb1_off_t rec_ptr;
 467         char *p = NULL;
 468         int ret = -1;
 469
 470         /* check for it existing, on insert. */
 471         if (flag == TDB_INSERT) {
 472                 if (tdb1_exists_hash(tdb, key, hash)) {
 473                         tdb->last_error = TDB_ERR_EXISTS;
 474                         goto fail;
 475                 }
 476         } else {
 477                 /* first try in-place update, on modify or replace. */
 478                 if (tdb1_update_hash(tdb, key, hash, dbuf) == 0) {
 479                         goto done;
 480                 }
 481                 if (tdb->last_error == TDB_ERR_NOEXIST &&
 482                     flag == TDB_MODIFY) {
 483                         /* if the record doesn't exist and we are in TDB1_MODIFY mode then
 484                          we should fail the store */
 485                         goto fail;
 486                 }
 487         }
 488         /* reset the error code potentially set by the tdb1_update() */
 489         tdb->last_error = TDB_SUCCESS;
 490
 491         /* delete any existing record - if it doesn't exist we don't
 492            care.  Doing this first reduces fragmentation, and avoids
 493            coalescing with `allocated' block before it's updated. */
 494         if (flag != TDB_INSERT)
 495                 tdb1_delete_hash(tdb, key, hash);
 496
 497         /* Copy key+value *before* allocating free space in case malloc
 498            fails and we are left with a dead spot in the tdb. */
 499
 500         if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
 501                 tdb->last_error = TDB_ERR_OOM;
 502                 goto fail;
 503         }
 504
 505         memcpy(p, key.dptr, key.dsize);
 506         if (dbuf.dsize)
 507                 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
 508
 509         if (tdb->tdb1.max_dead_records != 0) {
 510                 /*
 511                  * Allow for some dead records per hash chain, look if we can
 512                  * find one that can hold the new record. We need enough space
 513                  * for key, data and tailer. If we find one, we don't have to
 514                  * consult the central freelist.
 515                  */
 516                 rec_ptr = tdb1_find_dead(
 517                         tdb, hash, &rec,
 518                         key.dsize + dbuf.dsize + sizeof(tdb1_off_t));
 519
 520                 if (rec_ptr != 0) {
 521                         rec.key_len = key.dsize;
 522                         rec.data_len = dbuf.dsize;
 523                         rec.full_hash = hash;
 524                         rec.magic = TDB1_MAGIC;
 525                         if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
 526                             || tdb->tdb1.io->tdb1_write(
 527                                     tdb, rec_ptr + sizeof(rec),
 528                                     p, key.dsize + dbuf.dsize) == -1) {
 529                                 goto fail;
 530                         }
 531                         goto done;
 532                 }
 533         }
 534
 535         /*
 536          * We have to allocate some space from the freelist, so this means we
 537          * have to lock it. Use the chance to purge all the DEAD records from
 538          * the hash chain under the freelist lock.
 539          */
 540
 541         if (tdb1_lock(tdb, -1, F_WRLCK) == -1) {
 542                 goto fail;
 543         }
 544
 545         if ((tdb->tdb1.max_dead_records != 0)
 546             && (tdb1_purge_dead(tdb, hash) == -1)) {
 547                 tdb1_unlock(tdb, -1, F_WRLCK);
 548                 goto fail;
 549         }
 550
 551         /* we have to allocate some space */
 552         rec_ptr = tdb1_allocate(tdb, key.dsize + dbuf.dsize, &rec);
 553
 554         tdb1_unlock(tdb, -1, F_WRLCK);
 555
 556         if (rec_ptr == 0) {
 557                 goto fail;
 558         }
 559
 560         /* Read hash top into next ptr */
 561         if (tdb1_ofs_read(tdb, TDB1_HASH_TOP(hash), &rec.next) == -1)
 562                 goto fail;
 563
 564         rec.key_len = key.dsize;
 565         rec.data_len = dbuf.dsize;
 566         rec.full_hash = hash;
 567         rec.magic = TDB1_MAGIC;
 568
 569         /* write out and point the top of the hash chain at it */
 570         if (tdb1_rec_write(tdb, rec_ptr, &rec) == -1
 571             || tdb->tdb1.io->tdb1_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
 572             || tdb1_ofs_write(tdb, TDB1_HASH_TOP(hash), &rec_ptr) == -1) {
 573                 /* Need to tdb1_unallocate() here */
 574                 goto fail;
 575         }
 576
 577  done:
 578         ret = 0;
 579  fail:
 580         if (ret == 0) {
 581                 tdb1_increment_seqnum(tdb);
 582         }
 583
 584         SAFE_FREE(p);
 585         return ret;
 586 }
 587
 588 /* store an element in the database, replacing any existing element
 589    with the same key
 590
 591    return 0 on success, -1 on failure
 592 */
 593 int tdb1_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
 594 {
 595         uint32_t hash;
 596         int ret;
 597
 598         assert(tdb->flags & TDB_VERSION1);
 599
 600         if ((tdb->flags & TDB_RDONLY) || tdb->tdb1.traverse_read) {
 601                 tdb->last_error = tdb_logerr(tdb, TDB_ERR_RDONLY,
 602                                              TDB_LOG_USE_ERROR,
 603                                              "tdb_store: read-only tdb");
 604                 return -1;
 605         }
 606
 607         /* find which hash bucket it is in */
 608         hash = tdb_hash(tdb, key.dptr, key.dsize);
 609         if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
 610                 return -1;
 611
 612         ret = _tdb1_store(tdb, key, dbuf, flag, hash);
 613         tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
 614         return ret;
 615 }
 616
 617 /* Append to an entry. Create if not exist. */
 618 int tdb1_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
 619 {
 620         uint32_t hash;
 621         TDB_DATA dbuf;
 622         int ret = -1;
 623
 624         assert(tdb->flags & TDB_VERSION1);
 625
 626         /* find which hash bucket it is in */
 627         hash = tdb_hash(tdb, key.dptr, key.dsize);
 628         if (tdb1_lock(tdb, TDB1_BUCKET(hash), F_WRLCK) == -1)
 629                 return -1;
 630
 631         dbuf = _tdb1_fetch(tdb, key);
 632
 633         if (dbuf.dptr == NULL) {
 634                 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
 635         } else {
 636                 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
 637                 unsigned char *new_dptr;
 638
 639                 /* realloc '0' is special: don't do that. */
 640                 if (new_len == 0)
 641                         new_len = 1;
 642                 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
 643                 if (new_dptr == NULL) {
 644                         free(dbuf.dptr);
 645                 }
 646                 dbuf.dptr = new_dptr;
 647         }
 648
 649         if (dbuf.dptr == NULL) {
 650                 tdb->last_error = TDB_ERR_OOM;
 651                 goto failed;
 652         }
 653
 654         memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
 655         dbuf.dsize += new_dbuf.dsize;
 656
 657         ret = _tdb1_store(tdb, key, dbuf, 0, hash);
 658
 659 failed:
 660         tdb1_unlock(tdb, TDB1_BUCKET(hash), F_WRLCK);
 661         SAFE_FREE(dbuf.dptr);
 662         return ret;
 663 }
 664
 665
 666 /*
 667   get the tdb sequence number. Only makes sense if the writers opened
 668   with TDB1_SEQNUM set. Note that this sequence number will wrap quite
 669   quickly, so it should only be used for a 'has something changed'
 670   test, not for code that relies on the count of the number of changes
 671   made. If you want a counter then use a tdb record.
 672
 673   The aim of this sequence number is to allow for a very lightweight
 674   test of a possible tdb change.
 675 */
 676 int tdb1_get_seqnum(struct tdb_context *tdb)
 677 {
 678         tdb1_off_t seqnum=0;
 679
 680         tdb1_ofs_read(tdb, TDB1_SEQNUM_OFS, &seqnum);
 681         return seqnum;
 682 }
 683
 684
 685 /*
 686   add a region of the file to the freelist. Length is the size of the region in bytes,
 687   which includes the free list header that needs to be added
 688  */
 689 static int tdb1_free_region(struct tdb_context *tdb, tdb1_off_t offset, ssize_t length)
 690 {
 691         struct tdb1_record rec;
 692         if (length <= sizeof(rec)) {
 693                 /* the region is not worth adding */
 694                 return 0;
 695         }
 696         if (length + offset > tdb->file->map_size) {
 697                 tdb->last_error = tdb_logerr(tdb, TDB_ERR_CORRUPT, TDB_LOG_ERROR,
 698                                         "tdb1_free_region: adding region beyond"
 699                                         " end of file");
 700                 return -1;
 701         }
 702         memset(&rec,'\0',sizeof(rec));
 703         rec.rec_len = length - sizeof(rec);
 704         if (tdb1_free(tdb, offset, &rec) == -1) {
 705                 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 706                            "tdb1_free_region: failed to add free record");
 707                 return -1;
 708         }
 709         return 0;
 710 }
 711
 712 /*
 713   wipe the entire database, deleting all records. This can be done
 714   very fast by using a allrecord lock. The entire data portion of the
 715   file becomes a single entry in the freelist.
 716
 717   This code carefully steps around the recovery area, leaving it alone
 718  */
 719 int tdb1_wipe_all(struct tdb_context *tdb)
 720 {
 721         int i;
 722         tdb1_off_t offset = 0;
 723         ssize_t data_len;
 724         tdb1_off_t recovery_head;
 725         tdb1_len_t recovery_size = 0;
 726
 727         if (tdb_lockall(tdb) != TDB_SUCCESS) {
 728                 return -1;
 729         }
 730
 731
 732         /* see if the tdb has a recovery area, and remember its size
 733            if so. We don't want to lose this as otherwise each
 734            tdb1_wipe_all() in a transaction will increase the size of
 735            the tdb by the size of the recovery area */
 736         if (tdb1_ofs_read(tdb, TDB1_RECOVERY_HEAD, &recovery_head) == -1) {
 737                 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 738                            "tdb1_wipe_all: failed to read recovery head");
 739                 goto failed;
 740         }
 741
 742         if (recovery_head != 0) {
 743                 struct tdb1_record rec;
 744                 if (tdb->tdb1.io->tdb1_read(tdb, recovery_head, &rec, sizeof(rec), TDB1_DOCONV()) == -1) {
 745                         tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 746                                    "tdb1_wipe_all: failed to read recovery record");
 747                         return -1;
 748                 }
 749                 recovery_size = rec.rec_len + sizeof(rec);
 750         }
 751
 752         /* wipe the hashes */
 753         for (i=0;i<tdb->tdb1.header.hash_size;i++) {
 754                 if (tdb1_ofs_write(tdb, TDB1_HASH_TOP(i), &offset) == -1) {
 755                         tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 756                                    "tdb1_wipe_all: failed to write hash %d", i);
 757                         goto failed;
 758                 }
 759         }
 760
 761         /* wipe the freelist */
 762         if (tdb1_ofs_write(tdb, TDB1_FREELIST_TOP, &offset) == -1) {
 763                 tdb_logerr(tdb, tdb->last_error, TDB_LOG_ERROR,
 764                            "tdb1_wipe_all: failed to write freelist");
 765                 goto failed;
 766         }
 767
 768         /* add all the rest of the file to the freelist, possibly leaving a gap
 769            for the recovery area */
 770         if (recovery_size == 0) {
 771                 /* the simple case - the whole file can be used as a freelist */
 772                 data_len = (tdb->file->map_size - TDB1_DATA_START(tdb->tdb1.header.hash_size));
 773                 if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
 774                         goto failed;
 775                 }
 776         } else {
 777                 /* we need to add two freelist entries - one on either
 778                    side of the recovery area
 779
 780                    Note that we cannot shift the recovery area during
 781                    this operation. Only the transaction.c code may
 782                    move the recovery area or we risk subtle data
 783                    corruption
 784                 */
 785                 data_len = (recovery_head - TDB1_DATA_START(tdb->tdb1.header.hash_size));
 786                 if (tdb1_free_region(tdb, TDB1_DATA_START(tdb->tdb1.header.hash_size), data_len) != 0) {
 787                         goto failed;
 788                 }
 789                 /* and the 2nd free list entry after the recovery area - if any */
 790                 data_len = tdb->file->map_size - (recovery_head+recovery_size);
 791                 if (tdb1_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
 792                         goto failed;
 793                 }
 794         }
 795
 796         tdb1_increment_seqnum_nonblock(tdb);
 797         tdb_unlockall(tdb);
 798         return 0;
 799
 800 failed:
 801         tdb_unlockall(tdb);
 802         return -1;
 803 }
 804
 805 /* Even on files, we can get partial writes due to signals. */
 806 bool tdb1_write_all(int fd, const void *buf, size_t count)
 807 {
 808         while (count) {
 809                 ssize_t ret;
 810                 ret = write(fd, buf, count);
 811                 if (ret < 0)
 812                         return false;
 813                 buf = (const char *)buf + ret;
 814                 count -= ret;
 815         }
 816         return true;
 817 }