git.ozlabs.org Git - ccan/blob - ccan/tdb/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 "tdb_private.h"
  29
  30 TDB_DATA tdb_null;
  31
  32 /*
  33   non-blocking increment of the tdb sequence number if the tdb has been opened using
  34   the TDB_SEQNUM flag
  35 */
  36 void tdb_increment_seqnum_nonblock(struct tdb_context *tdb)
  37 {
  38         tdb_off_t seqnum=0;
  39
  40         if (!(tdb->flags & TDB_SEQNUM)) {
  41                 return;
  42         }
  43
  44         /* we ignore errors from this, as we have no sane way of
  45            dealing with them.
  46         */
  47         tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
  48         seqnum++;
  49         tdb_ofs_write(tdb, TDB_SEQNUM_OFS, &seqnum);
  50 }
  51
  52 /*
  53   increment the tdb sequence number if the tdb has been opened using
  54   the TDB_SEQNUM flag
  55 */
  56 static void tdb_increment_seqnum(struct tdb_context *tdb)
  57 {
  58         if (!(tdb->flags & TDB_SEQNUM)) {
  59                 return;
  60         }
  61
  62         if (tdb_brlock(tdb, TDB_SEQNUM_OFS, F_WRLCK, F_SETLKW, 1, 1) != 0) {
  63                 return;
  64         }
  65
  66         tdb_increment_seqnum_nonblock(tdb);
  67
  68         tdb_brlock(tdb, TDB_SEQNUM_OFS, F_UNLCK, F_SETLKW, 1, 1);
  69 }
  70
  71 static int tdb_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 tdb_off_t tdb_find(struct tdb_context *tdb, TDB_DATA key, uint32_t hash,
  79                         struct list_struct *r)
  80 {
  81         tdb_off_t rec_ptr;
  82
  83         /* read in the hash top */
  84         if (tdb_ofs_read(tdb, TDB_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 (tdb_rec_read(tdb, rec_ptr, r) == -1)
  90                         return 0;
  91
  92                 if (!TDB_DEAD(r) && hash==r->full_hash
  93                     && key.dsize==r->key_len
  94                     && tdb_parse_data(tdb, key, rec_ptr + sizeof(*r),
  95                                       r->key_len, tdb_key_compare,
  96                                       NULL) == 0) {
  97                         return rec_ptr;
  98                 }
  99                 rec_ptr = r->next;
 100         }
 101         return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
 102 }
 103
 104 /* As tdb_find, but if you succeed, keep the lock */
 105 tdb_off_t tdb_find_lock_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, int locktype,
 106                            struct list_struct *rec)
 107 {
 108         uint32_t rec_ptr;
 109
 110         if (tdb_lock(tdb, BUCKET(hash), locktype) == -1)
 111                 return 0;
 112         if (!(rec_ptr = tdb_find(tdb, key, hash, rec)))
 113                 tdb_unlock(tdb, BUCKET(hash), locktype);
 114         return rec_ptr;
 115 }
 116
 117
 118 /* update an entry in place - this only works if the new data size
 119    is <= the old data size and the key exists.
 120    on failure return -1.
 121 */
 122 static int tdb_update_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash, TDB_DATA dbuf)
 123 {
 124         struct list_struct rec;
 125         tdb_off_t rec_ptr;
 126
 127         /* find entry */
 128         if (!(rec_ptr = tdb_find(tdb, key, hash, &rec)))
 129                 return -1;
 130
 131         /* must be long enough key, data and tailer */
 132         if (rec.rec_len < key.dsize + dbuf.dsize + sizeof(tdb_off_t)) {
 133                 tdb->ecode = TDB_SUCCESS; /* Not really an error */
 134                 return -1;
 135         }
 136
 137         if (tdb->methods->tdb_write(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 138                       dbuf.dptr, dbuf.dsize) == -1)
 139                 return -1;
 140
 141         if (dbuf.dsize != rec.data_len) {
 142                 /* update size */
 143                 rec.data_len = dbuf.dsize;
 144                 return tdb_rec_write(tdb, rec_ptr, &rec);
 145         }
 146
 147         return 0;
 148 }
 149
 150 /* find an entry in the database given a key */
 151 /* If an entry doesn't exist tdb_err will be set to
 152  * TDB_ERR_NOEXIST. If a key has no data attached
 153  * then the TDB_DATA will have zero length but
 154  * a non-zero pointer
 155  */
 156 static TDB_DATA do_tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
 157 {
 158         tdb_off_t rec_ptr;
 159         struct list_struct rec;
 160         TDB_DATA ret;
 161         uint32_t hash;
 162
 163         /* find which hash bucket it is in */
 164         hash = tdb->hash_fn(&key);
 165         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 166                 return tdb_null;
 167         }
 168         ret.dptr = tdb_alloc_read(tdb, rec_ptr + sizeof(rec) + rec.key_len,
 169                                   rec.data_len);
 170         ret.dsize = rec.data_len;
 171         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 172         return ret;
 173 }
 174
 175 TDB_DATA tdb_fetch(struct tdb_context *tdb, TDB_DATA key)
 176 {
 177         TDB_DATA ret = do_tdb_fetch(tdb, key);
 178
 179         tdb_trace_1rec_retrec(tdb, "tdb_fetch", key, ret);
 180         return ret;
 181 }
 182
 183 /*
 184  * Find an entry in the database and hand the record's data to a parsing
 185  * function. The parsing function is executed under the chain read lock, so it
 186  * should be fast and should not block on other syscalls.
 187  *
 188  * DONT CALL OTHER TDB CALLS FROM THE PARSER, THIS MIGHT LEAD TO SEGFAULTS.
 189  *
 190  * For mmapped tdb's that do not have a transaction open it points the parsing
 191  * function directly at the mmap area, it avoids the malloc/memcpy in this
 192  * case. If a transaction is open or no mmap is available, it has to do
 193  * malloc/read/parse/free.
 194  *
 195  * This is interesting for all readers of potentially large data structures in
 196  * the tdb records, ldb indexes being one example.
 197  */
 198
 199 int tdb_parse_record(struct tdb_context *tdb, TDB_DATA key,
 200                      int (*parser)(TDB_DATA key, TDB_DATA data,
 201                                    void *private_data),
 202                      void *private_data)
 203 {
 204         tdb_off_t rec_ptr;
 205         struct list_struct rec;
 206         int ret;
 207         uint32_t hash;
 208
 209         /* find which hash bucket it is in */
 210         hash = tdb->hash_fn(&key);
 211
 212         if (!(rec_ptr = tdb_find_lock_hash(tdb,key,hash,F_RDLCK,&rec))) {
 213                 tdb_trace_1rec_ret(tdb, "tdb_parse_record", key,
 214                                    -TDB_ERR_NOEXIST);
 215                 return TDB_ERRCODE(TDB_ERR_NOEXIST, 0);
 216         }
 217         tdb_trace_1rec_ret(tdb, "tdb_parse_record", key, 0);
 218
 219         ret = tdb_parse_data(tdb, key, rec_ptr + sizeof(rec) + rec.key_len,
 220                              rec.data_len, parser, private_data);
 221
 222         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 223
 224         return ret;
 225 }
 226
 227 /* check if an entry in the database exists
 228
 229    note that 1 is returned if the key is found and 0 is returned if not found
 230    this doesn't match the conventions in the rest of this module, but is
 231    compatible with gdbm
 232 */
 233 static int tdb_exists_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 234 {
 235         struct list_struct rec;
 236
 237         if (tdb_find_lock_hash(tdb, key, hash, F_RDLCK, &rec) == 0)
 238                 return 0;
 239         tdb_unlock(tdb, BUCKET(rec.full_hash), F_RDLCK);
 240         return 1;
 241 }
 242
 243 int tdb_exists(struct tdb_context *tdb, TDB_DATA key)
 244 {
 245         uint32_t hash = tdb->hash_fn(&key);
 246         int ret;
 247
 248         ret = tdb_exists_hash(tdb, key, hash);
 249         tdb_trace_1rec_ret(tdb, "tdb_exists", key, ret);
 250         return ret;
 251 }
 252
 253 /* actually delete an entry in the database given the offset */
 254 int tdb_do_delete(struct tdb_context *tdb, tdb_off_t rec_ptr, struct list_struct *rec)
 255 {
 256         tdb_off_t last_ptr, i;
 257         struct list_struct lastrec;
 258
 259         if (tdb->read_only || tdb->traverse_read) return -1;
 260
 261         if (tdb->traverse_write != 0 ||
 262             tdb_write_lock_record(tdb, rec_ptr) == -1) {
 263                 /* Someone traversing here: mark it as dead */
 264                 rec->magic = TDB_DEAD_MAGIC;
 265                 return tdb_rec_write(tdb, rec_ptr, rec);
 266         }
 267         if (tdb_write_unlock_record(tdb, rec_ptr) != 0)
 268                 return -1;
 269
 270         /* find previous record in hash chain */
 271         if (tdb_ofs_read(tdb, TDB_HASH_TOP(rec->full_hash), &i) == -1)
 272                 return -1;
 273         for (last_ptr = 0; i != rec_ptr; last_ptr = i, i = lastrec.next)
 274                 if (tdb_rec_read(tdb, i, &lastrec) == -1)
 275                         return -1;
 276
 277         /* unlink it: next ptr is at start of record. */
 278         if (last_ptr == 0)
 279                 last_ptr = TDB_HASH_TOP(rec->full_hash);
 280         if (tdb_ofs_write(tdb, last_ptr, &rec->next) == -1)
 281                 return -1;
 282
 283         /* recover the space */
 284         if (tdb_free(tdb, rec_ptr, rec) == -1)
 285                 return -1;
 286         return 0;
 287 }
 288
 289 static int tdb_count_dead(struct tdb_context *tdb, uint32_t hash)
 290 {
 291         int res = 0;
 292         tdb_off_t rec_ptr;
 293         struct list_struct rec;
 294
 295         /* read in the hash top */
 296         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 297                 return 0;
 298
 299         while (rec_ptr) {
 300                 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1)
 301                         return 0;
 302
 303                 if (rec.magic == TDB_DEAD_MAGIC) {
 304                         res += 1;
 305                 }
 306                 rec_ptr = rec.next;
 307         }
 308         return res;
 309 }
 310
 311 /*
 312  * Purge all DEAD records from a hash chain
 313  */
 314 static int tdb_purge_dead(struct tdb_context *tdb, uint32_t hash)
 315 {
 316         int res = -1;
 317         struct list_struct rec;
 318         tdb_off_t rec_ptr;
 319
 320         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 321                 return -1;
 322         }
 323
 324         /* read in the hash top */
 325         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 326                 goto fail;
 327
 328         while (rec_ptr) {
 329                 tdb_off_t next;
 330
 331                 if (tdb_rec_read(tdb, rec_ptr, &rec) == -1) {
 332                         goto fail;
 333                 }
 334
 335                 next = rec.next;
 336
 337                 if (rec.magic == TDB_DEAD_MAGIC
 338                     && tdb_do_delete(tdb, rec_ptr, &rec) == -1) {
 339                         goto fail;
 340                 }
 341                 rec_ptr = next;
 342         }
 343         res = 0;
 344  fail:
 345         tdb_unlock(tdb, -1, F_WRLCK);
 346         return res;
 347 }
 348
 349 /* delete an entry in the database given a key */
 350 static int tdb_delete_hash(struct tdb_context *tdb, TDB_DATA key, uint32_t hash)
 351 {
 352         tdb_off_t rec_ptr;
 353         struct list_struct rec;
 354         int ret;
 355
 356         if (tdb->max_dead_records != 0) {
 357
 358                 /*
 359                  * Allow for some dead records per hash chain, mainly for
 360                  * tdb's with a very high create/delete rate like locking.tdb.
 361                  */
 362
 363                 if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 364                         return -1;
 365
 366                 if (tdb_count_dead(tdb, hash) >= tdb->max_dead_records) {
 367                         /*
 368                          * Don't let the per-chain freelist grow too large,
 369                          * delete all existing dead records
 370                          */
 371                         tdb_purge_dead(tdb, hash);
 372                 }
 373
 374                 if (!(rec_ptr = tdb_find(tdb, key, hash, &rec))) {
 375                         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 376                         return -1;
 377                 }
 378
 379                 /*
 380                  * Just mark the record as dead.
 381                  */
 382                 rec.magic = TDB_DEAD_MAGIC;
 383                 ret = tdb_rec_write(tdb, rec_ptr, &rec);
 384         }
 385         else {
 386                 if (!(rec_ptr = tdb_find_lock_hash(tdb, key, hash, F_WRLCK,
 387                                                    &rec)))
 388                         return -1;
 389
 390                 ret = tdb_do_delete(tdb, rec_ptr, &rec);
 391         }
 392
 393         if (ret == 0) {
 394                 tdb_increment_seqnum(tdb);
 395         }
 396
 397         if (tdb_unlock(tdb, BUCKET(rec.full_hash), F_WRLCK) != 0)
 398                 TDB_LOG((tdb, TDB_DEBUG_WARNING, "tdb_delete: WARNING tdb_unlock failed!\n"));
 399         return ret;
 400 }
 401
 402 int tdb_delete(struct tdb_context *tdb, TDB_DATA key)
 403 {
 404         uint32_t hash = tdb->hash_fn(&key);
 405         int ret;
 406
 407         ret = tdb_delete_hash(tdb, key, hash);
 408         tdb_trace_1rec_ret(tdb, "tdb_delete", key, ret);
 409         return ret;
 410 }
 411
 412 /*
 413  * See if we have a dead record around with enough space
 414  */
 415 static tdb_off_t tdb_find_dead(struct tdb_context *tdb, uint32_t hash,
 416                                struct list_struct *r, tdb_len_t length)
 417 {
 418         tdb_off_t rec_ptr;
 419
 420         /* read in the hash top */
 421         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1)
 422                 return 0;
 423
 424         /* keep looking until we find the right record */
 425         while (rec_ptr) {
 426                 if (tdb_rec_read(tdb, rec_ptr, r) == -1)
 427                         return 0;
 428
 429                 if (TDB_DEAD(r) && r->rec_len >= length) {
 430                         /*
 431                          * First fit for simple coding, TODO: change to best
 432                          * fit
 433                          */
 434                         return rec_ptr;
 435                 }
 436                 rec_ptr = r->next;
 437         }
 438         return 0;
 439 }
 440
 441 static int _tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf,
 442                       int flag, uint32_t hash)
 443 {
 444         struct list_struct rec;
 445         tdb_off_t rec_ptr;
 446         char *p = NULL;
 447         int ret = -1;
 448
 449         /* check for it existing, on insert. */
 450         if (flag == TDB_INSERT) {
 451                 if (tdb_exists_hash(tdb, key, hash)) {
 452                         tdb->ecode = TDB_ERR_EXISTS;
 453                         goto fail;
 454                 }
 455         } else {
 456                 /* first try in-place update, on modify or replace. */
 457                 if (tdb_update_hash(tdb, key, hash, dbuf) == 0) {
 458                         goto done;
 459                 }
 460                 if (tdb->ecode == TDB_ERR_NOEXIST &&
 461                     flag == TDB_MODIFY) {
 462                         /* if the record doesn't exist and we are in TDB_MODIFY mode then
 463                          we should fail the store */
 464                         goto fail;
 465                 }
 466         }
 467         /* reset the error code potentially set by the tdb_update() */
 468         tdb->ecode = TDB_SUCCESS;
 469
 470         /* delete any existing record - if it doesn't exist we don't
 471            care.  Doing this first reduces fragmentation, and avoids
 472            coalescing with `allocated' block before it's updated. */
 473         if (flag != TDB_INSERT)
 474                 tdb_delete_hash(tdb, key, hash);
 475
 476         /* Copy key+value *before* allocating free space in case malloc
 477            fails and we are left with a dead spot in the tdb. */
 478
 479         if (!(p = (char *)malloc(key.dsize + dbuf.dsize))) {
 480                 tdb->ecode = TDB_ERR_OOM;
 481                 goto fail;
 482         }
 483
 484         memcpy(p, key.dptr, key.dsize);
 485         if (dbuf.dsize)
 486                 memcpy(p+key.dsize, dbuf.dptr, dbuf.dsize);
 487
 488         if (tdb->max_dead_records != 0) {
 489                 /*
 490                  * Allow for some dead records per hash chain, look if we can
 491                  * find one that can hold the new record. We need enough space
 492                  * for key, data and tailer. If we find one, we don't have to
 493                  * consult the central freelist.
 494                  */
 495                 rec_ptr = tdb_find_dead(
 496                         tdb, hash, &rec,
 497                         key.dsize + dbuf.dsize + sizeof(tdb_off_t));
 498
 499                 if (rec_ptr != 0) {
 500                         rec.key_len = key.dsize;
 501                         rec.data_len = dbuf.dsize;
 502                         rec.full_hash = hash;
 503                         rec.magic = TDB_MAGIC;
 504                         if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
 505                             || tdb->methods->tdb_write(
 506                                     tdb, rec_ptr + sizeof(rec),
 507                                     p, key.dsize + dbuf.dsize) == -1) {
 508                                 goto fail;
 509                         }
 510                         goto done;
 511                 }
 512         }
 513
 514         /*
 515          * We have to allocate some space from the freelist, so this means we
 516          * have to lock it. Use the chance to purge all the DEAD records from
 517          * the hash chain under the freelist lock.
 518          */
 519
 520         if (tdb_lock(tdb, -1, F_WRLCK) == -1) {
 521                 goto fail;
 522         }
 523
 524         if ((tdb->max_dead_records != 0)
 525             && (tdb_purge_dead(tdb, hash) == -1)) {
 526                 tdb_unlock(tdb, -1, F_WRLCK);
 527                 goto fail;
 528         }
 529
 530         /* we have to allocate some space */
 531         rec_ptr = tdb_allocate(tdb, key.dsize + dbuf.dsize, &rec);
 532
 533         tdb_unlock(tdb, -1, F_WRLCK);
 534
 535         if (rec_ptr == 0) {
 536                 goto fail;
 537         }
 538
 539         /* Read hash top into next ptr */
 540         if (tdb_ofs_read(tdb, TDB_HASH_TOP(hash), &rec.next) == -1)
 541                 goto fail;
 542
 543         rec.key_len = key.dsize;
 544         rec.data_len = dbuf.dsize;
 545         rec.full_hash = hash;
 546         rec.magic = TDB_MAGIC;
 547
 548         /* write out and point the top of the hash chain at it */
 549         if (tdb_rec_write(tdb, rec_ptr, &rec) == -1
 550             || tdb->methods->tdb_write(tdb, rec_ptr+sizeof(rec), p, key.dsize+dbuf.dsize)==-1
 551             || tdb_ofs_write(tdb, TDB_HASH_TOP(hash), &rec_ptr) == -1) {
 552                 /* Need to tdb_unallocate() here */
 553                 goto fail;
 554         }
 555
 556  done:
 557         ret = 0;
 558  fail:
 559         if (ret == 0) {
 560                 tdb_increment_seqnum(tdb);
 561         }
 562
 563         SAFE_FREE(p);
 564         return ret;
 565 }
 566
 567 /* store an element in the database, replacing any existing element
 568    with the same key
 569
 570    return 0 on success, -1 on failure
 571 */
 572 int tdb_store(struct tdb_context *tdb, TDB_DATA key, TDB_DATA dbuf, int flag)
 573 {
 574         uint32_t hash;
 575         int ret;
 576
 577         if (tdb->read_only || tdb->traverse_read) {
 578                 tdb->ecode = TDB_ERR_RDONLY;
 579                 tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag,
 580                                         -TDB_ERR_RDONLY);
 581                 return -1;
 582         }
 583
 584         /* find which hash bucket it is in */
 585         hash = tdb->hash_fn(&key);
 586         if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 587                 return -1;
 588
 589         ret = _tdb_store(tdb, key, dbuf, flag, hash);
 590         tdb_trace_2rec_flag_ret(tdb, "tdb_store", key, dbuf, flag, ret);
 591         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 592         return ret;
 593 }
 594
 595
 596 /* Append to an entry. Create if not exist. */
 597 int tdb_append(struct tdb_context *tdb, TDB_DATA key, TDB_DATA new_dbuf)
 598 {
 599         uint32_t hash;
 600         TDB_DATA dbuf;
 601         int ret = -1;
 602
 603         /* find which hash bucket it is in */
 604         hash = tdb->hash_fn(&key);
 605         if (tdb_lock(tdb, BUCKET(hash), F_WRLCK) == -1)
 606                 return -1;
 607
 608         dbuf = do_tdb_fetch(tdb, key);
 609
 610         if (dbuf.dptr == NULL) {
 611                 dbuf.dptr = (unsigned char *)malloc(new_dbuf.dsize);
 612         } else {
 613                 unsigned int new_len = dbuf.dsize + new_dbuf.dsize;
 614                 unsigned char *new_dptr;
 615
 616                 /* realloc '0' is special: don't do that. */
 617                 if (new_len == 0)
 618                         new_len = 1;
 619                 new_dptr = (unsigned char *)realloc(dbuf.dptr, new_len);
 620                 if (new_dptr == NULL) {
 621                         free(dbuf.dptr);
 622                 }
 623                 dbuf.dptr = new_dptr;
 624         }
 625
 626         if (dbuf.dptr == NULL) {
 627                 tdb->ecode = TDB_ERR_OOM;
 628                 goto failed;
 629         }
 630
 631         memcpy(dbuf.dptr + dbuf.dsize, new_dbuf.dptr, new_dbuf.dsize);
 632         dbuf.dsize += new_dbuf.dsize;
 633
 634         ret = _tdb_store(tdb, key, dbuf, 0, hash);
 635         tdb_trace_2rec_retrec(tdb, "tdb_append", key, new_dbuf, dbuf);
 636
 637 failed:
 638         tdb_unlock(tdb, BUCKET(hash), F_WRLCK);
 639         SAFE_FREE(dbuf.dptr);
 640         return ret;
 641 }
 642
 643
 644 /*
 645   return the name of the current tdb file
 646   useful for external logging functions
 647 */
 648 const char *tdb_name(struct tdb_context *tdb)
 649 {
 650         return tdb->name;
 651 }
 652
 653 /*
 654   return the underlying file descriptor being used by tdb, or -1
 655   useful for external routines that want to check the device/inode
 656   of the fd
 657 */
 658 int tdb_fd(struct tdb_context *tdb)
 659 {
 660         return tdb->fd;
 661 }
 662
 663 /*
 664   return the current logging function
 665   useful for external tdb routines that wish to log tdb errors
 666 */
 667 tdb_log_func tdb_log_fn(struct tdb_context *tdb)
 668 {
 669         return tdb->log.log_fn;
 670 }
 671
 672
 673 /*
 674   get the tdb sequence number. Only makes sense if the writers opened
 675   with TDB_SEQNUM set. Note that this sequence number will wrap quite
 676   quickly, so it should only be used for a 'has something changed'
 677   test, not for code that relies on the count of the number of changes
 678   made. If you want a counter then use a tdb record.
 679
 680   The aim of this sequence number is to allow for a very lightweight
 681   test of a possible tdb change.
 682 */
 683 int tdb_get_seqnum(struct tdb_context *tdb)
 684 {
 685         tdb_off_t seqnum=0;
 686
 687         tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
 688         tdb_trace_ret(tdb, "tdb_get_seqnum", seqnum);
 689         return seqnum;
 690 }
 691
 692 int tdb_hash_size(struct tdb_context *tdb)
 693 {
 694         return tdb->header.hash_size;
 695 }
 696
 697 size_t tdb_map_size(struct tdb_context *tdb)
 698 {
 699         return tdb->map_size;
 700 }
 701
 702 int tdb_get_flags(struct tdb_context *tdb)
 703 {
 704         return tdb->flags;
 705 }
 706
 707 void tdb_add_flags(struct tdb_context *tdb, unsigned flags)
 708 {
 709         tdb->flags |= flags;
 710 }
 711
 712 void tdb_remove_flags(struct tdb_context *tdb, unsigned flags)
 713 {
 714         tdb->flags &= ~flags;
 715 }
 716
 717
 718 /*
 719   enable sequence number handling on an open tdb
 720 */
 721 void tdb_enable_seqnum(struct tdb_context *tdb)
 722 {
 723         tdb->flags |= TDB_SEQNUM;
 724 }
 725
 726
 727 /*
 728   add a region of the file to the freelist. Length is the size of the region in bytes,
 729   which includes the free list header that needs to be added
 730  */
 731 static int tdb_free_region(struct tdb_context *tdb, tdb_off_t offset, ssize_t length)
 732 {
 733         struct list_struct rec;
 734         if (length <= sizeof(rec)) {
 735                 /* the region is not worth adding */
 736                 return 0;
 737         }
 738         if (length + offset > tdb->map_size) {
 739                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: adding region beyond end of file\n"));
 740                 return -1;
 741         }
 742         memset(&rec,'\0',sizeof(rec));
 743         rec.rec_len = length - sizeof(rec);
 744         if (tdb_free(tdb, offset, &rec) == -1) {
 745                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_free_region: failed to add free record\n"));
 746                 return -1;
 747         }
 748         return 0;
 749 }
 750
 751 /*
 752   wipe the entire database, deleting all records. This can be done
 753   very fast by using a global lock. The entire data portion of the
 754   file becomes a single entry in the freelist.
 755
 756   This code carefully steps around the recovery area, leaving it alone
 757  */
 758 int tdb_wipe_all(struct tdb_context *tdb)
 759 {
 760         int i;
 761         tdb_off_t offset = 0;
 762         ssize_t data_len;
 763         tdb_off_t recovery_head;
 764         tdb_len_t recovery_size = 0;
 765
 766         if (tdb_lockall(tdb) != 0) {
 767                 return -1;
 768         }
 769
 770         tdb_trace(tdb, "tdb_wipe_all");
 771
 772         /* see if the tdb has a recovery area, and remember its size
 773            if so. We don't want to lose this as otherwise each
 774            tdb_wipe_all() in a transaction will increase the size of
 775            the tdb by the size of the recovery area */
 776         if (tdb_ofs_read(tdb, TDB_RECOVERY_HEAD, &recovery_head) == -1) {
 777                 TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery head\n"));
 778                 goto failed;
 779         }
 780
 781         if (recovery_head != 0) {
 782                 struct list_struct rec;
 783                 if (tdb->methods->tdb_read(tdb, recovery_head, &rec, sizeof(rec), DOCONV()) == -1) {
 784                         TDB_LOG((tdb, TDB_DEBUG_FATAL, "tdb_wipe_all: failed to read recovery record\n"));
 785                         return -1;
 786                 }
 787                 recovery_size = rec.rec_len + sizeof(rec);
 788         }
 789
 790         /* wipe the hashes */
 791         for (i=0;i<tdb->header.hash_size;i++) {
 792                 if (tdb_ofs_write(tdb, TDB_HASH_TOP(i), &offset) == -1) {
 793                         TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write hash %d\n", i));
 794                         goto failed;
 795                 }
 796         }
 797
 798         /* wipe the freelist */
 799         if (tdb_ofs_write(tdb, FREELIST_TOP, &offset) == -1) {
 800                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to write freelist\n"));
 801                 goto failed;
 802         }
 803
 804         /* add all the rest of the file to the freelist, possibly leaving a gap
 805            for the recovery area */
 806         if (recovery_size == 0) {
 807                 /* the simple case - the whole file can be used as a freelist */
 808                 data_len = (tdb->map_size - TDB_DATA_START(tdb->header.hash_size));
 809                 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
 810                         goto failed;
 811                 }
 812         } else {
 813                 /* we need to add two freelist entries - one on either
 814                    side of the recovery area
 815
 816                    Note that we cannot shift the recovery area during
 817                    this operation. Only the transaction.c code may
 818                    move the recovery area or we risk subtle data
 819                    corruption
 820                 */
 821                 data_len = (recovery_head - TDB_DATA_START(tdb->header.hash_size));
 822                 if (tdb_free_region(tdb, TDB_DATA_START(tdb->header.hash_size), data_len) != 0) {
 823                         goto failed;
 824                 }
 825                 /* and the 2nd free list entry after the recovery area - if any */
 826                 data_len = tdb->map_size - (recovery_head+recovery_size);
 827                 if (tdb_free_region(tdb, recovery_head+recovery_size, data_len) != 0) {
 828                         goto failed;
 829                 }
 830         }
 831
 832         if (tdb_unlockall(tdb) != 0) {
 833                 TDB_LOG((tdb, TDB_DEBUG_FATAL,"tdb_wipe_all: failed to unlock\n"));
 834                 goto failed;
 835         }
 836
 837         return 0;
 838
 839 failed:
 840         tdb_unlockall(tdb);
 841         return -1;
 842 }
 843
 844 #ifdef TDB_TRACE
 845 static void tdb_trace_write(struct tdb_context *tdb, const char *str)
 846 {
 847         if (write(tdb->tracefd, str, strlen(str)) != strlen(str)) {
 848                 close(tdb->tracefd);
 849                 tdb->tracefd = -1;
 850         }
 851 }
 852
 853 static void tdb_trace_start(struct tdb_context *tdb)
 854 {
 855         tdb_off_t seqnum=0;
 856         char msg[sizeof(tdb_off_t) * 4];
 857
 858         tdb_ofs_read(tdb, TDB_SEQNUM_OFS, &seqnum);
 859         sprintf(msg, "%u ", seqnum);
 860         tdb_trace_write(tdb, msg);
 861 }
 862
 863 static void tdb_trace_end(struct tdb_context *tdb)
 864 {
 865         tdb_trace_write(tdb, "\n");
 866 }
 867
 868 static void tdb_trace_end_ret(struct tdb_context *tdb, int ret)
 869 {
 870         char msg[sizeof(ret) * 4];
 871         sprintf(msg, " = %i\n", ret);
 872         tdb_trace_write(tdb, msg);
 873 }
 874
 875 static void tdb_trace_record(struct tdb_context *tdb, TDB_DATA rec)
 876 {
 877         char msg[20];
 878         unsigned int i;
 879
 880         /* We differentiate zero-length records from non-existent ones. */
 881         if (rec.dptr == NULL) {
 882                 tdb_trace_write(tdb, " NULL");
 883                 return;
 884         }
 885         sprintf(msg, " %zu:", rec.dsize);
 886         tdb_trace_write(tdb, msg);
 887         for (i = 0; i < rec.dsize; i++) {
 888                 sprintf(msg, "%02x", rec.dptr[i]);
 889                 tdb_trace_write(tdb, msg);
 890         }
 891 }
 892
 893 void tdb_trace(struct tdb_context *tdb, const char *op)
 894 {
 895         tdb_trace_start(tdb);
 896         tdb_trace_write(tdb, op);
 897         tdb_trace_end(tdb);
 898 }
 899
 900 void tdb_trace_open(struct tdb_context *tdb, const char *op,
 901                     unsigned hash_size, unsigned tdb_flags, unsigned open_flags)
 902 {
 903         char msg[128];
 904
 905         sprintf(msg, "%s %u %#x %#x", op, hash_size, tdb_flags, open_flags);
 906         tdb_trace_start(tdb);
 907         tdb_trace_write(tdb, msg);
 908         tdb_trace_end(tdb);
 909 }
 910
 911 void tdb_trace_ret(struct tdb_context *tdb, const char *op, int ret)
 912 {
 913         tdb_trace_start(tdb);
 914         tdb_trace_write(tdb, op);
 915         tdb_trace_end_ret(tdb, ret);
 916 }
 917
 918 void tdb_trace_retrec(struct tdb_context *tdb, const char *op, TDB_DATA ret)
 919 {
 920         tdb_trace_start(tdb);
 921         tdb_trace_write(tdb, op);
 922         tdb_trace_write(tdb, " =");
 923         tdb_trace_record(tdb, ret);
 924         tdb_trace_end(tdb);
 925 }
 926
 927 void tdb_trace_1rec(struct tdb_context *tdb, const char *op,
 928                     TDB_DATA rec)
 929 {
 930         tdb_trace_start(tdb);
 931         tdb_trace_write(tdb, op);
 932         tdb_trace_record(tdb, rec);
 933         tdb_trace_end(tdb);
 934 }
 935
 936 void tdb_trace_1rec_ret(struct tdb_context *tdb, const char *op,
 937                         TDB_DATA rec, int ret)
 938 {
 939         tdb_trace_start(tdb);
 940         tdb_trace_write(tdb, op);
 941         tdb_trace_record(tdb, rec);
 942         tdb_trace_end_ret(tdb, ret);
 943 }
 944
 945 void tdb_trace_1rec_retrec(struct tdb_context *tdb, const char *op,
 946                            TDB_DATA rec, TDB_DATA ret)
 947 {
 948         tdb_trace_start(tdb);
 949         tdb_trace_write(tdb, op);
 950         tdb_trace_record(tdb, rec);
 951         tdb_trace_write(tdb, " =");
 952         tdb_trace_record(tdb, ret);
 953         tdb_trace_end(tdb);
 954 }
 955
 956 void tdb_trace_2rec_flag_ret(struct tdb_context *tdb, const char *op,
 957                              TDB_DATA rec1, TDB_DATA rec2, unsigned flag,
 958                              int ret)
 959 {
 960         char msg[sizeof(ret) * 4];
 961
 962         sprintf(msg, " %#x", flag);
 963         tdb_trace_start(tdb);
 964         tdb_trace_write(tdb, op);
 965         tdb_trace_record(tdb, rec1);
 966         tdb_trace_record(tdb, rec2);
 967         tdb_trace_write(tdb, msg);
 968         tdb_trace_end_ret(tdb, ret);
 969 }
 970
 971 void tdb_trace_2rec_retrec(struct tdb_context *tdb, const char *op,
 972                            TDB_DATA rec1, TDB_DATA rec2, TDB_DATA ret)
 973 {
 974         tdb_trace_start(tdb);
 975         tdb_trace_write(tdb, op);
 976         tdb_trace_record(tdb, rec1);
 977         tdb_trace_record(tdb, rec2);
 978         tdb_trace_write(tdb, " =");
 979         tdb_trace_record(tdb, ret);
 980         tdb_trace_end(tdb);
 981 }
 982 #endif