5 TDB version 2: trivial database library
7 Copyright (C) Andrew Tridgell 1999-2004
8 Copyright (C) Rusty Russell 2010-2011
10 ** NOTE! The following LGPL license applies to the tdb
11 ** library. This does NOT imply that all of Samba is released
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.
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.
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/>.
34 #if HAVE_FILE_OFFSET_BITS
35 #define _FILE_OFFSET_BITS 64
38 #include <sys/types.h>
41 /* For sig_atomic_t. */
50 #include <ccan/compiler/compiler.h>
51 #include <ccan/typesafe_cb/typesafe_cb.h>
52 #include <ccan/cast/cast.h>
58 * tdb_open - open a database file
59 * @name: the file name (can be NULL if flags contains TDB_INTERNAL)
60 * @tdb_flags: options for this database
61 * @open_flags: flags argument for tdb's open() call.
62 * @mode: mode argument for tdb's open() call.
63 * @attributes: linked list of extra attributes for this tdb.
65 * This call opens (and potentially creates) a database file.
66 * Multiple processes can have the TDB file open at once.
68 * On failure it will return NULL, and set errno: it may also call
69 * any log attribute found in @attributes.
74 struct tdb_context *tdb_open(const char *name, int tdb_flags,
75 int open_flags, mode_t mode,
76 union tdb_attribute *attributes);
79 /* flags for tdb_open() */
80 #define TDB_DEFAULT 0 /* just a readability place holder */
81 #define TDB_INTERNAL 2 /* don't store on disk */
82 #define TDB_NOLOCK 4 /* don't do any locking */
83 #define TDB_NOMMAP 8 /* don't use mmap */
84 #define TDB_CONVERT 16 /* convert endian */
85 #define TDB_NOSYNC 64 /* don't use synchronous transactions */
86 #define TDB_SEQNUM 128 /* maintain a sequence number */
87 #define TDB_ALLOW_NESTING 256 /* fake nested transactions */
88 #define TDB_RDONLY 512 /* implied by O_RDONLY */
89 #define TDB_VERSION1 1024 /* create/open an old style TDB */
90 #define TDB_CANT_CHECK 2048 /* has a feature which we don't understand */
93 * tdb1_incompatible_hash - better (Jenkins) hash for tdb1
95 * This is better than the default hash for tdb1; but older versions of the
96 * tdb library (prior to version 1.2.6) won't be able to open them.
98 * It only makes sense to specify this (using tdb_attribute_hash) when
99 * creating (with O_CREAT) an old tdb version using TDB_VERSION1. It's
100 * equivalent to the TDB_INCOMPATIBLE_HASH flag for tdb1.
102 uint64_t tdb1_incompatible_hash(const void *, size_t, uint64_t, void *);
105 * tdb_close - close and free a tdb.
106 * @tdb: the tdb context returned from tdb_open()
108 * This always succeeds, in that @tdb is unusable after this call. But if
109 * some unexpected error occurred while closing, it will return non-zero
110 * (the only clue as to cause will be via the log attribute).
112 int tdb_close(struct tdb_context *tdb);
115 * struct tdb_data - representation of keys or values.
116 * @dptr: the data pointer
117 * @dsize: the size of the data pointed to by dptr.
119 * This is the "blob" representation of keys and data used by TDB.
121 typedef struct tdb_data {
127 * enum TDB_ERROR - error returns for TDB
133 TDB_SUCCESS = 0, /* No error. */
134 TDB_ERR_CORRUPT = -1, /* We read the db, and it was bogus. */
135 TDB_ERR_IO = -2, /* We couldn't read/write the db. */
136 TDB_ERR_LOCK = -3, /* Locking failed. */
137 TDB_ERR_OOM = -4, /* Out of Memory. */
138 TDB_ERR_EXISTS = -5, /* The key already exists. */
139 TDB_ERR_NOEXIST = -6, /* The key does not exist. */
140 TDB_ERR_EINVAL = -7, /* You're using it wrong. */
141 TDB_ERR_RDONLY = -8, /* The database is read-only. */
142 TDB_ERR_LAST = TDB_ERR_RDONLY
146 * tdb_store - store a key/value pair in a tdb.
147 * @tdb: the tdb context returned from tdb_open()
149 * @dbuf: the data to associate with the key.
150 * @flag: TDB_REPLACE, TDB_INSERT or TDB_MODIFY.
152 * This inserts (or overwrites) a key/value pair in the TDB. If flag
153 * is TDB_REPLACE, it doesn't matter whether the key exists or not;
154 * TDB_INSERT means it must not exist (returns TDB_ERR_EXISTS otherwise),
155 * and TDB_MODIFY means it must exist (returns TDB_ERR_NOEXIST otherwise).
157 * On success, this returns TDB_SUCCESS.
160 * tdb_fetch, tdb_transaction_start, tdb_append, tdb_delete.
162 enum TDB_ERROR tdb_store(struct tdb_context *tdb,
164 struct tdb_data dbuf,
167 /* flags to tdb_store() */
168 #define TDB_REPLACE 1 /* A readability place holder */
169 #define TDB_INSERT 2 /* Don't overwrite an existing entry */
170 #define TDB_MODIFY 3 /* Don't create an existing entry */
173 * tdb_fetch - fetch a value from a tdb.
174 * @tdb: the tdb context returned from tdb_open()
176 * @data: pointer to data.
178 * This looks up a key in the database and sets it in @data.
180 * If it returns TDB_SUCCESS, the key was found: it is your
181 * responsibility to call free() on @data->dptr.
183 * Otherwise, it returns an error (usually, TDB_ERR_NOEXIST) and @data is
186 enum TDB_ERROR tdb_fetch(struct tdb_context *tdb, struct tdb_data key,
187 struct tdb_data *data);
190 * tdb_errorstr - map the tdb error onto a constant readable string
191 * @ecode: the enum TDB_ERROR to map.
193 * This is useful for displaying errors to users.
195 const char *tdb_errorstr(enum TDB_ERROR ecode);
198 * tdb_append - append a value to a key/value pair in a tdb.
199 * @tdb: the tdb context returned from tdb_open()
201 * @dbuf: the data to append.
203 * This is equivalent to fetching a record, reallocating .dptr to add the
204 * data, and writing it back, only it's much more efficient. If the key
205 * doesn't exist, it's equivalent to tdb_store (with an additional hint that
206 * you expect to expand the record in future).
209 * tdb_fetch(), tdb_store()
211 enum TDB_ERROR tdb_append(struct tdb_context *tdb,
212 struct tdb_data key, struct tdb_data dbuf);
215 * tdb_delete - delete a key from a tdb.
216 * @tdb: the tdb context returned from tdb_open()
217 * @key: the key to delete.
219 * Returns TDB_SUCCESS on success, or an error (usually TDB_ERR_NOEXIST).
222 * tdb_fetch(), tdb_store()
224 enum TDB_ERROR tdb_delete(struct tdb_context *tdb, struct tdb_data key);
227 * tdb_exists - does a key exist in the database?
228 * @tdb: the tdb context returned from tdb_open()
229 * @key: the key to search for.
231 * Returns true if it exists, or false if it doesn't or any other error.
233 bool tdb_exists(struct tdb_context *tdb, TDB_DATA key);
236 * tdb_deq - are struct tdb_data equal?
237 * @a: one struct tdb_data
238 * @b: another struct tdb_data
240 static inline bool tdb_deq(struct tdb_data a, struct tdb_data b)
242 return a.dsize == b.dsize && memcmp(a.dptr, b.dptr, a.dsize) == 0;
246 * tdb_mkdata - make a struct tdb_data from const data
247 * @p: the constant pointer
250 * As the dptr member of struct tdb_data is not constant, you need to
251 * cast it. This function keeps thost casts in one place, as well as
252 * suppressing the warning some compilers give when casting away a
253 * qualifier (eg. gcc with -Wcast-qual)
255 static inline struct tdb_data tdb_mkdata(const void *p, size_t len)
258 d.dptr = cast_const(void *, p);
264 * tdb_transaction_start - start a transaction
265 * @tdb: the tdb context returned from tdb_open()
267 * This begins a series of atomic operations. Other processes will be able
268 * to read the tdb, but not alter it (they will block), nor will they see
269 * any changes until tdb_transaction_commit() is called.
271 * Note that if the TDB_ALLOW_NESTING flag is set, a tdb_transaction_start()
272 * within a transaction will succeed, but it's not a real transaction:
273 * (1) An inner transaction which is committed is not actually committed until
274 * the outer transaction is; if the outer transaction is cancelled, the
275 * inner ones are discarded.
276 * (2) tdb_transaction_cancel() marks the outer transaction as having an error,
277 * so the final tdb_transaction_commit() will fail.
278 * (3) the outer transaction will see the results of the inner transaction.
281 * tdb_transaction_cancel, tdb_transaction_commit.
283 enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb);
286 * tdb_transaction_cancel - abandon a transaction
287 * @tdb: the tdb context returned from tdb_open()
289 * This aborts a transaction, discarding any changes which were made.
290 * tdb_close() does this implicitly.
292 void tdb_transaction_cancel(struct tdb_context *tdb);
295 * tdb_transaction_commit - commit a transaction
296 * @tdb: the tdb context returned from tdb_open()
298 * This completes a transaction, writing any changes which were made.
300 * fsync() is used to commit the transaction (unless TDB_NOSYNC is set),
301 * making it robust against machine crashes, but very slow compared to
302 * other TDB operations.
304 * A failure can only be caused by unexpected errors (eg. I/O or
305 * memory); this is no point looping on transaction failure.
308 * tdb_transaction_prepare_commit()
310 enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb);
313 * tdb_transaction_prepare_commit - prepare to commit a transaction
314 * @tdb: the tdb context returned from tdb_open()
316 * This ensures we have the resources to commit a transaction (using
317 * tdb_transaction_commit): if this succeeds then a transaction will only
318 * fail if the write() or fsync() calls fail.
320 * If this fails you must still call tdb_transaction_cancel() to cancel
324 * tdb_transaction_commit()
326 enum TDB_ERROR tdb_transaction_prepare_commit(struct tdb_context *tdb);
329 * tdb_traverse - traverse a TDB
330 * @tdb: the tdb context returned from tdb_open()
331 * @fn: the function to call for every key/value pair (or NULL)
332 * @p: the pointer to hand to @f
334 * This walks the TDB until all they keys have been traversed, or @fn
335 * returns non-zero. If the traverse function or other processes are
336 * changing data or adding or deleting keys, the traverse may be
337 * unreliable: keys may be skipped or (rarely) visited twice.
339 * There is one specific exception: the special case of deleting the
340 * current key does not undermine the reliability of the traversal.
342 * On success, returns the number of keys iterated. On error returns
343 * a negative enum TDB_ERROR value.
345 #define tdb_traverse(tdb, fn, p) \
346 tdb_traverse_(tdb, typesafe_cb_preargs(int, void *, (fn), (p), \
347 struct tdb_context *, \
348 TDB_DATA, TDB_DATA), (p))
350 int64_t tdb_traverse_(struct tdb_context *tdb,
351 int (*fn)(struct tdb_context *,
352 TDB_DATA, TDB_DATA, void *), void *p);
355 * tdb_parse_record - operate directly on data in the database.
356 * @tdb: the tdb context returned from tdb_open()
357 * @key: the key whose record we should hand to @parse
358 * @parse: the function to call for the data
359 * @data: the private pointer to hand to @parse (types must match).
361 * This avoids a copy for many cases, by handing you a pointer into
362 * the memory-mapped database. It also locks the record to prevent
363 * other accesses at the same time.
365 * Do not alter the data handed to parse()!
367 #define tdb_parse_record(tdb, key, parse, data) \
368 tdb_parse_record_((tdb), (key), \
369 typesafe_cb_preargs(enum TDB_ERROR, void *, \
371 TDB_DATA, TDB_DATA), (data))
373 enum TDB_ERROR tdb_parse_record_(struct tdb_context *tdb,
375 enum TDB_ERROR (*parse)(TDB_DATA k,
381 * tdb_get_seqnum - get a database sequence number
382 * @tdb: the tdb context returned from tdb_open()
384 * This returns a sequence number: any change to the database from a
385 * tdb context opened with the TDB_SEQNUM flag will cause that number
386 * to increment. Note that the incrementing is unreliable (it is done
387 * without locking), so this is only useful as an optimization.
389 * For example, you may have a regular database backup routine which
390 * does not operate if the sequence number is unchanged. In the
391 * unlikely event of a failed increment, it will be backed up next
394 * Returns an enum TDB_ERROR (ie. negative) on error.
396 int64_t tdb_get_seqnum(struct tdb_context *tdb);
399 * tdb_firstkey - get the "first" key in a TDB
400 * @tdb: the tdb context returned from tdb_open()
401 * @key: pointer to key.
403 * This returns an arbitrary key in the database; with tdb_nextkey() it allows
404 * open-coded traversal of the database, though it is slightly less efficient
407 * It is your responsibility to free @key->dptr on success.
409 * Returns TDB_ERR_NOEXIST if the database is empty.
411 enum TDB_ERROR tdb_firstkey(struct tdb_context *tdb, struct tdb_data *key);
414 * tdb_nextkey - get the "next" key in a TDB
415 * @tdb: the tdb context returned from tdb_open()
416 * @key: a key returned by tdb_firstkey() or tdb_nextkey().
418 * This returns another key in the database; it will free @key.dptr for
421 * Returns TDB_ERR_NOEXIST if there are no more keys.
423 enum TDB_ERROR tdb_nextkey(struct tdb_context *tdb, struct tdb_data *key);
426 * tdb_chainlock - lock a record in the TDB
427 * @tdb: the tdb context returned from tdb_open()
428 * @key: the key to lock.
430 * This prevents any access occurring to a group of keys including @key,
431 * even if @key does not exist. This allows primitive atomic updates of
432 * records without using transactions.
434 * You cannot begin a transaction while holding a tdb_chainlock(), nor can
435 * you do any operations on any other keys in the database. This also means
436 * that you cannot hold more than one tdb_chainlock() at a time.
441 enum TDB_ERROR tdb_chainlock(struct tdb_context *tdb, TDB_DATA key);
444 * tdb_chainunlock - unlock a record in the TDB
445 * @tdb: the tdb context returned from tdb_open()
446 * @key: the key to unlock.
448 * The key must have previously been locked by tdb_chainlock().
450 void tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key);
453 * tdb_chainlock_read - lock a record in the TDB, for reading
454 * @tdb: the tdb context returned from tdb_open()
455 * @key: the key to lock.
457 * This prevents any changes from occurring to a group of keys including @key,
458 * even if @key does not exist. This allows primitive atomic updates of
459 * records without using transactions.
461 * You cannot begin a transaction while holding a tdb_chainlock_read(), nor can
462 * you do any operations on any other keys in the database. This also means
463 * that you cannot hold more than one tdb_chainlock()/read() at a time.
468 enum TDB_ERROR tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
471 * tdb_chainunlock_read - unlock a record in the TDB for reading
472 * @tdb: the tdb context returned from tdb_open()
473 * @key: the key to unlock.
475 * The key must have previously been locked by tdb_chainlock_read().
477 void tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
480 * tdb_lockall - lock the entire TDB
481 * @tdb: the tdb context returned from tdb_open()
483 * You cannot hold a tdb_chainlock while calling this. It nests, so you
484 * must call tdb_unlockall as many times as you call tdb_lockall.
486 enum TDB_ERROR tdb_lockall(struct tdb_context *tdb);
489 * tdb_unlockall - unlock the entire TDB
490 * @tdb: the tdb context returned from tdb_open()
492 void tdb_unlockall(struct tdb_context *tdb);
495 * tdb_lockall_read - lock the entire TDB for reading
496 * @tdb: the tdb context returned from tdb_open()
498 * This prevents others writing to the database, eg. tdb_delete, tdb_store,
499 * tdb_append, but not tdb_fetch.
501 * You cannot hold a tdb_chainlock while calling this. It nests, so you
502 * must call tdb_unlockall_read as many times as you call tdb_lockall_read.
504 enum TDB_ERROR tdb_lockall_read(struct tdb_context *tdb);
507 * tdb_unlockall_read - unlock the entire TDB for reading
508 * @tdb: the tdb context returned from tdb_open()
510 void tdb_unlockall_read(struct tdb_context *tdb);
513 * tdb_wipe_all - wipe the database clean
514 * @tdb: the tdb context returned from tdb_open()
516 * Completely erase the database. This is faster than iterating through
517 * each key and doing tdb_delete.
519 enum TDB_ERROR tdb_wipe_all(struct tdb_context *tdb);
522 * tdb_repack - repack the database
523 * @tdb: the tdb context returned from tdb_open()
525 * This repacks the database; if it is suffering from a great deal of
526 * fragmentation this might help. However, it can take twice the
527 * memory of the existing TDB.
529 enum TDB_ERROR tdb_repack(struct tdb_context *tdb);
532 * tdb_check - check a TDB for consistency
533 * @tdb: the tdb context returned from tdb_open()
534 * @check: function to check each key/data pair (or NULL)
535 * @data: argument for @check, must match type.
537 * This performs a consistency check of the open database, optionally calling
538 * a check() function on each record so you can do your own data consistency
539 * checks as well. If check() returns an error, that is returned from
542 * Note that the TDB uses a feature which we don't understand which
543 * indicates we can't run tdb_check(), this will log a warning to that
544 * effect and return TDB_SUCCESS. You can detect this condition by
545 * looking for TDB_CANT_CHECK in tdb_get_flags().
547 * Returns TDB_SUCCESS or an error.
549 #define tdb_check(tdb, check, data) \
550 tdb_check_((tdb), typesafe_cb_preargs(enum TDB_ERROR, void *, \
556 enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
557 enum TDB_ERROR (*check)(struct tdb_data k,
563 * tdb_error - get the last error (not threadsafe)
564 * @tdb: the tdb context returned from tdb_open()
566 * Returns the last error returned by a TDB function.
568 * This makes porting from TDB1 easier, but note that the last error is not
569 * reliable in threaded programs.
571 enum TDB_ERROR tdb_error(struct tdb_context *tdb);
574 * enum tdb_summary_flags - flags for tdb_summary.
576 enum tdb_summary_flags {
577 TDB_SUMMARY_HISTOGRAMS = 1 /* Draw graphs in the summary. */
581 * tdb_summary - return a string describing the TDB state
582 * @tdb: the tdb context returned from tdb_open()
583 * @flags: flags to control the summary output.
584 * @summary: pointer to string to allocate.
586 * This returns a developer-readable string describing the overall
587 * state of the tdb, such as the percentage used and sizes of records.
588 * It is designed to provide information about the tdb at a glance
589 * without displaying any keys or data in the database.
591 * On success, sets @summary to point to a malloc()'ed nul-terminated
592 * multi-line string. It is your responsibility to free() it.
594 enum TDB_ERROR tdb_summary(struct tdb_context *tdb,
595 enum tdb_summary_flags flags,
600 * tdb_get_flags - return the flags for a tdb
601 * @tdb: the tdb context returned from tdb_open()
603 * This returns the flags on the current tdb. Some of these are caused by
604 * the flags argument to tdb_open(), others (such as TDB_CONVERT) are
607 unsigned int tdb_get_flags(struct tdb_context *tdb);
610 * tdb_add_flag - set a flag for a tdb
611 * @tdb: the tdb context returned from tdb_open()
612 * @flag: one of TDB_NOLOCK, TDB_NOMMAP, TDB_NOSYNC or TDB_ALLOW_NESTING.
614 * You can use this to set a flag on the TDB. You cannot set these flags
615 * on a TDB_INTERNAL tdb.
617 void tdb_add_flag(struct tdb_context *tdb, unsigned flag);
620 * tdb_remove_flag - unset a flag for a tdb
621 * @tdb: the tdb context returned from tdb_open()
622 * @flag: one of TDB_NOLOCK, TDB_NOMMAP, TDB_NOSYNC or TDB_ALLOW_NESTING.
624 * You can use this to clear a flag on the TDB. You cannot clear flags
625 * on a TDB_INTERNAL tdb.
627 void tdb_remove_flag(struct tdb_context *tdb, unsigned flag);
630 * enum tdb_attribute_type - descriminator for union tdb_attribute.
632 enum tdb_attribute_type {
633 TDB_ATTRIBUTE_LOG = 0,
634 TDB_ATTRIBUTE_HASH = 1,
635 TDB_ATTRIBUTE_SEED = 2,
636 TDB_ATTRIBUTE_STATS = 3,
637 TDB_ATTRIBUTE_OPENHOOK = 4,
638 TDB_ATTRIBUTE_FLOCK = 5,
639 TDB_ATTRIBUTE_TDB1_HASHSIZE = 128,
640 TDB_ATTRIBUTE_TDB1_MAX_DEAD = 129,
644 * tdb_get_attribute - get an attribute for an existing tdb
645 * @tdb: the tdb context returned from tdb_open()
646 * @attr: the union tdb_attribute to set.
648 * This gets an attribute from a TDB which has previously been set (or
649 * may return the default values). Set @attr.base.attr to the
650 * attribute type you want get.
652 enum TDB_ERROR tdb_get_attribute(struct tdb_context *tdb,
653 union tdb_attribute *attr);
656 * tdb_set_attribute - set an attribute for an existing tdb
657 * @tdb: the tdb context returned from tdb_open()
658 * @attr: the union tdb_attribute to set.
660 * This sets an attribute on a TDB, overriding any previous attribute
661 * of the same type. It returns TDB_ERR_EINVAL if the attribute is
662 * unknown or invalid.
664 * Note that TDB_ATTRIBUTE_HASH, TDB_ATTRIBUTE_SEED,
665 * TDB_ATTRIBUTE_OPENHOOK and TDB_ATTRIBUTE_TDB1_HASHSIZE cannot
666 * currently be set after tdb_open.
668 enum TDB_ERROR tdb_set_attribute(struct tdb_context *tdb,
669 const union tdb_attribute *attr);
672 * tdb_unset_attribute - reset an attribute for an existing tdb
673 * @tdb: the tdb context returned from tdb_open()
674 * @type: the attribute type to unset.
676 * This unsets an attribute on a TDB, returning it to the defaults
677 * (where applicable).
679 * Note that it only makes sense for TDB_ATTRIBUTE_LOG and TDB_ATTRIBUTE_FLOCK
682 void tdb_unset_attribute(struct tdb_context *tdb,
683 enum tdb_attribute_type type);
686 * tdb_name - get the name of a tdb
687 * @tdb: the tdb context returned from tdb_open()
689 * This returns a copy of the name string, made at tdb_open() time. If that
690 * argument was NULL (possible for a TDB_INTERNAL db) this will return NULL.
692 * This is mostly useful for logging.
694 const char *tdb_name(const struct tdb_context *tdb);
697 * tdb_fd - get the file descriptor of a tdb
698 * @tdb: the tdb context returned from tdb_open()
700 * This returns the file descriptor for the underlying database file, or -1
703 int tdb_fd(const struct tdb_context *tdb);
706 * tdb_foreach - iterate through every open TDB.
707 * @fn: the function to call for every TDB
708 * @p: the pointer to hand to @fn
710 * TDB internally keeps track of all open TDBs; this function allows you to
711 * iterate through them. If @fn returns non-zero, traversal stops.
713 #define tdb_foreach(fn, p) \
714 tdb_foreach_(typesafe_cb_preargs(int, void *, (fn), (p), \
715 struct tdb_context *), (p))
717 void tdb_foreach_(int (*fn)(struct tdb_context *, void *), void *p);
720 * struct tdb_attribute_base - common fields for all tdb attributes.
722 struct tdb_attribute_base {
723 enum tdb_attribute_type attr;
724 union tdb_attribute *next;
728 * enum tdb_log_level - log levels for tdb_attribute_log
729 * @TDB_LOG_ERROR: used to log unrecoverable errors such as I/O errors
730 * or internal consistency failures.
731 * @TDB_LOG_USE_ERROR: used to log usage errors such as invalid parameters
732 * or writing to a read-only database.
733 * @TDB_LOG_WARNING: used for informational messages on issues which
734 * are unusual but handled by TDB internally, such
735 * as a failure to mmap or failure to open /dev/urandom.
744 * struct tdb_attribute_log - log function attribute
746 * This attribute provides a hook for you to log errors.
748 struct tdb_attribute_log {
749 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_LOG */
750 void (*fn)(struct tdb_context *tdb,
751 enum tdb_log_level level,
752 enum TDB_ERROR ecode,
759 * struct tdb_attribute_hash - hash function attribute
761 * This attribute allows you to provide an alternative hash function.
762 * This hash function will be handed keys from the database; it will also
763 * be handed the 8-byte TDB_HASH_MAGIC value for checking the header (the
764 * tdb_open() will fail if the hash value doesn't match the header).
766 * Note that if your hash function gives different results on
767 * different machine endians, your tdb will no longer work across
768 * different architectures!
770 struct tdb_attribute_hash {
771 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_HASH */
772 uint64_t (*fn)(const void *key, size_t len, uint64_t seed,
778 * struct tdb_attribute_seed - hash function seed attribute
780 * The hash function seed is normally taken from /dev/urandom (or equivalent)
781 * but can be set manually here. This is mainly for testing purposes.
783 struct tdb_attribute_seed {
784 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_SEED */
789 * struct tdb_attribute_stats - tdb operational statistics
791 * This attribute records statistics of various low-level TDB operations.
792 * This can be used to assist performance evaluation. This is only
793 * useful for tdb_get_attribute().
795 * New fields will be added at the end, hence the "size" argument which
796 * indicates how large your structure is: it must be filled in before
797 * calling tdb_get_attribute(), which will overwrite it with the size
800 struct tdb_attribute_stats {
801 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_STATS */
802 size_t size; /* = sizeof(struct tdb_attribute_stats) */
804 uint64_t alloc_subhash;
805 uint64_t alloc_chain;
806 uint64_t alloc_bucket_exact;
807 uint64_t alloc_bucket_max;
808 uint64_t alloc_leftover;
809 uint64_t alloc_coalesce_tried;
810 uint64_t alloc_coalesce_iterate_clash;
811 uint64_t alloc_coalesce_lockfail;
812 uint64_t alloc_coalesce_race;
813 uint64_t alloc_coalesce_succeeded;
814 uint64_t alloc_coalesce_num_merged;
816 uint64_t compare_wrong_bucket;
817 uint64_t compare_wrong_offsetbits;
818 uint64_t compare_wrong_keylen;
819 uint64_t compare_wrong_rechash;
820 uint64_t compare_wrong_keycmp;
821 uint64_t transactions;
822 uint64_t transaction_cancel;
823 uint64_t transaction_nest;
824 uint64_t transaction_expand_file;
825 uint64_t transaction_read_direct;
826 uint64_t transaction_read_direct_fail;
827 uint64_t transaction_write_direct;
828 uint64_t transaction_write_direct_fail;
832 uint64_t lock_lowlevel;
833 uint64_t lock_nonblock;
834 uint64_t lock_nonblock_fail;
838 * struct tdb_attribute_openhook - tdb special effects hook for open
840 * This attribute contains a function to call once we have the OPEN_LOCK
841 * for the tdb, but before we've examined its contents. If this succeeds,
842 * the tdb will be populated if it's then zero-length.
844 * This is a hack to allow support for TDB1-style TDB_CLEAR_IF_FIRST
847 struct tdb_attribute_openhook {
848 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_OPENHOOK */
849 enum TDB_ERROR (*fn)(int fd, void *data);
854 * struct tdb_attribute_flock - tdb special effects hook for file locking
856 * This attribute contains function to call to place locks on a file; it can
857 * be used to support non-blocking operations or lock proxying.
859 * They should return 0 on success, -1 on failure and set errno.
861 * An error will be logged on error if errno is neither EAGAIN nor EINTR
862 * (normally it would only return EAGAIN if waitflag is false, and
863 * loop internally on EINTR).
865 struct tdb_attribute_flock {
866 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_FLOCK */
867 int (*lock)(int fd,int rw, off_t off, off_t len, bool waitflag, void *);
868 int (*unlock)(int fd, int rw, off_t off, off_t len, void *);
873 * struct tdb_attribute_tdb1_hashsize - tdb1 hashsize
875 * This attribute allows setting the TDB1 hashsize; it only makes sense with
876 * O_CREAT and TDB_VERSION1.
878 * Hashsize should generally be a prime, such as 10007.
880 struct tdb_attribute_tdb1_hashsize {
881 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_TDB1_HASHSIZE */
886 * struct tdb_attribute_tdb1_max_dead - tdb1 number of maximum dead records.
888 * TDB1 has a method to speed up its slow free list: it lets a certain
889 * number of "dead" records build up before freeing them. This is
890 * particularly useful for volatile TDBs; setting it to 5 is
891 * equivalent to tdb1's TDB_VOLATILE flag.
893 struct tdb_attribute_tdb1_max_dead {
894 struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_TDB1_MAX_DEAD */
895 unsigned int max_dead;
899 * union tdb_attribute - tdb attributes.
901 * This represents all the known attributes.
904 * struct tdb_attribute_log, struct tdb_attribute_hash,
905 * struct tdb_attribute_seed, struct tdb_attribute_stats,
906 * struct tdb_attribute_openhook, struct tdb_attribute_flock.
908 union tdb_attribute {
909 struct tdb_attribute_base base;
910 struct tdb_attribute_log log;
911 struct tdb_attribute_hash hash;
912 struct tdb_attribute_seed seed;
913 struct tdb_attribute_stats stats;
914 struct tdb_attribute_openhook openhook;
915 struct tdb_attribute_flock flock;
916 struct tdb_attribute_tdb1_hashsize tdb1_hashsize;
917 struct tdb_attribute_tdb1_max_dead tdb1_max_dead;