tdb2: rearrange log function to put data arg at the end.
[ccan] / ccan / tdb2 / tdb2.h
1 #ifndef CCAN_TDB2_H
2 #define CCAN_TDB2_H
3
4 /*
5    TDB version 2: trivial database library
6
7    Copyright (C) Andrew Tridgell 1999-2004
8    Copyright (C) Rusty Russell 2010-2011
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 #ifdef  __cplusplus
29 extern "C" {
30 #endif
31
32 #ifndef _SAMBA_BUILD_
33 /* For mode_t */
34 #include <sys/types.h>
35 /* For O_* flags. */
36 #include <sys/stat.h>
37 /* For sig_atomic_t. */
38 #include <signal.h>
39 /* For uint64_t */
40 #include <stdint.h>
41 /* For bool */
42 #include <stdbool.h>
43 /* For memcmp */
44 #include <string.h>
45 #endif
46 #include <ccan/compiler/compiler.h>
47 #include <ccan/typesafe_cb/typesafe_cb.h>
48 #include <ccan/cast/cast.h>
49
50 union tdb_attribute;
51 struct tdb_context;
52
53 /**
54  * tdb_open - open a database file
55  * @name: the file name (can be NULL if flags contains TDB_INTERNAL)
56  * @tdb_flags: options for this database
57  * @open_flags: flags argument for tdb's open() call.
58  * @mode: mode argument for tdb's open() call.
59  * @attributes: linked list of extra attributes for this tdb.
60  *
61  * This call opens (and potentially creates) a database file.
62  * Multiple processes can have the TDB file open at once.
63  *
64  * On failure it will return NULL, and set errno: it may also call
65  * any log attribute found in @attributes.
66  *
67  * See also:
68  *      union tdb_attribute
69  */
70 struct tdb_context *tdb_open(const char *name, int tdb_flags,
71                              int open_flags, mode_t mode,
72                              union tdb_attribute *attributes);
73
74
75 /* flags for tdb_open() */
76 #define TDB_DEFAULT 0 /* just a readability place holder */
77 #define TDB_INTERNAL 2 /* don't store on disk */
78 #define TDB_NOLOCK   4 /* don't do any locking */
79 #define TDB_NOMMAP   8 /* don't use mmap */
80 #define TDB_CONVERT 16 /* convert endian */
81 #define TDB_NOSYNC   64 /* don't use synchronous transactions */
82 #define TDB_SEQNUM   128 /* maintain a sequence number */
83
84 /**
85  * tdb_close - close and free a tdb.
86  * @tdb: the tdb context returned from tdb_open()
87  *
88  * This always succeeds, in that @tdb is unusable after this call.  But if
89  * some unexpected error occurred while closing, it will return non-zero
90  * (the only clue as to cause will be via the log attribute).
91  */
92 int tdb_close(struct tdb_context *tdb);
93
94 /**
95  * struct tdb_data - representation of keys or values.
96  * @dptr: the data pointer
97  * @dsize: the size of the data pointed to by dptr.
98  *
99  * This is the "blob" representation of keys and data used by TDB.
100  */
101 typedef struct tdb_data {
102         unsigned char *dptr;
103         size_t dsize;
104 } TDB_DATA;
105
106 /**
107  * enum TDB_ERROR - error returns for TDB
108  *
109  * See Also:
110  *      tdb_errorstr()
111  */
112 enum TDB_ERROR {
113         TDB_SUCCESS     = 0,    /* No error. */
114         TDB_ERR_CORRUPT = -1,   /* We read the db, and it was bogus. */
115         TDB_ERR_IO      = -2,   /* We couldn't read/write the db. */
116         TDB_ERR_LOCK    = -3,   /* Locking failed. */
117         TDB_ERR_OOM     = -4,   /* Out of Memory. */
118         TDB_ERR_EXISTS  = -5,   /* The key already exists. */
119         TDB_ERR_NOEXIST = -6,   /* The key does not exist. */
120         TDB_ERR_EINVAL  = -7,   /* You're using it wrong. */
121         TDB_ERR_RDONLY  = -8,   /* The database is read-only. */
122         TDB_ERR_LAST = TDB_ERR_RDONLY
123 };
124
125 /**
126  * tdb_store - store a key/value pair in a tdb.
127  * @tdb: the tdb context returned from tdb_open()
128  * @key: the key
129  * @dbuf: the data to associate with the key.
130  * @flag: TDB_REPLACE, TDB_INSERT or TDB_MODIFY.
131  *
132  * This inserts (or overwrites) a key/value pair in the TDB.  If flag
133  * is TDB_REPLACE, it doesn't matter whether the key exists or not;
134  * TDB_INSERT means it must not exist (returns TDB_ERR_EXISTS otherwise),
135  * and TDB_MODIFY means it must exist (returns TDB_ERR_NOEXIST otherwise).
136  *
137  * On success, this returns TDB_SUCCESS.
138  *
139  * See also:
140  *      tdb_fetch, tdb_transaction_start, tdb_append, tdb_delete.
141  */
142 enum TDB_ERROR tdb_store(struct tdb_context *tdb,
143                          struct tdb_data key,
144                          struct tdb_data dbuf,
145                          int flag);
146
147 /* flags to tdb_store() */
148 #define TDB_REPLACE 1           /* A readability place holder */
149 #define TDB_INSERT 2            /* Don't overwrite an existing entry */
150 #define TDB_MODIFY 3            /* Don't create an existing entry    */
151
152 /**
153  * tdb_fetch - fetch a value from a tdb.
154  * @tdb: the tdb context returned from tdb_open()
155  * @key: the key
156  * @data: pointer to data.
157  *
158  * This looks up a key in the database and sets it in @data.
159  *
160  * If it returns TDB_SUCCESS, the key was found: it is your
161  * responsibility to call free() on @data->dptr.
162  *
163  * Otherwise, it returns an error (usually, TDB_ERR_NOEXIST) and @data is
164  * undefined.
165  */
166 enum TDB_ERROR tdb_fetch(struct tdb_context *tdb, struct tdb_data key,
167                          struct tdb_data *data);
168
169 /**
170  * tdb_errorstr - map the tdb error onto a constant readable string
171  * @ecode: the enum TDB_ERROR to map.
172  *
173  * This is useful for displaying errors to users.
174  */
175 const char *tdb_errorstr(enum TDB_ERROR ecode);
176
177 /**
178  * tdb_append - append a value to a key/value pair in a tdb.
179  * @tdb: the tdb context returned from tdb_open()
180  * @key: the key
181  * @dbuf: the data to append.
182  *
183  * This is equivalent to fetching a record, reallocating .dptr to add the
184  * data, and writing it back, only it's much more efficient.  If the key
185  * doesn't exist, it's equivalent to tdb_store (with an additional hint that
186  * you expect to expand the record in future).
187  *
188  * See Also:
189  *      tdb_fetch(), tdb_store()
190  */
191 enum TDB_ERROR tdb_append(struct tdb_context *tdb,
192                           struct tdb_data key, struct tdb_data dbuf);
193
194 /**
195  * tdb_delete - delete a key from a tdb.
196  * @tdb: the tdb context returned from tdb_open()
197  * @key: the key to delete.
198  *
199  * Returns TDB_SUCCESS on success, or an error (usually TDB_ERR_NOEXIST).
200  *
201  * See Also:
202  *      tdb_fetch(), tdb_store()
203  */
204 enum TDB_ERROR tdb_delete(struct tdb_context *tdb, struct tdb_data key);
205
206 /**
207  * tdb_exists - does a key exist in the database?
208  * @tdb: the tdb context returned from tdb_open()
209  * @key: the key to search for.
210  *
211  * Returns true if it exists, or false if it doesn't or any other error.
212  */
213 bool tdb_exists(struct tdb_context *tdb, TDB_DATA key);
214
215 /**
216  * tdb_deq - are struct tdb_data equal?
217  * @a: one struct tdb_data
218  * @b: another struct tdb_data
219  */
220 static inline bool tdb_deq(struct tdb_data a, struct tdb_data b)
221 {
222         return a.dsize == b.dsize && memcmp(a.dptr, b.dptr, a.dsize) == 0;
223 }
224
225 /**
226  * tdb_mkdata - make a struct tdb_data from const data
227  * @p: the constant pointer
228  * @len: the length
229  *
230  * As the dptr member of struct tdb_data is not constant, you need to
231  * cast it.  This function keeps thost casts in one place, as well as
232  * suppressing the warning some compilers give when casting away a
233  * qualifier (eg. gcc with -Wcast-qual)
234  */
235 static inline struct tdb_data tdb_mkdata(const void *p, size_t len)
236 {
237         struct tdb_data d;
238         d.dptr = cast_const(void *, p);
239         d.dsize = len;
240         return d;
241 }
242
243 /**
244  * tdb_transaction_start - start a transaction
245  * @tdb: the tdb context returned from tdb_open()
246  *
247  * This begins a series of atomic operations.  Other processes will be able
248  * to read the tdb, but not alter it (they will block), nor will they see
249  * any changes until tdb_transaction_commit() is called.
250  *
251  * See Also:
252  *      tdb_transaction_cancel, tdb_transaction_commit.
253  */
254 enum TDB_ERROR tdb_transaction_start(struct tdb_context *tdb);
255
256 /**
257  * tdb_transaction_cancel - abandon a transaction
258  * @tdb: the tdb context returned from tdb_open()
259  *
260  * This aborts a transaction, discarding any changes which were made.
261  * tdb_close() does this implicitly.
262  */
263 void tdb_transaction_cancel(struct tdb_context *tdb);
264
265 /**
266  * tdb_transaction_commit - commit a transaction
267  * @tdb: the tdb context returned from tdb_open()
268  *
269  * This completes a transaction, writing any changes which were made.
270  *
271  * fsync() is used to commit the transaction (unless TDB_NOSYNC is set),
272  * making it robust against machine crashes, but very slow compared to
273  * other TDB operations.
274  *
275  * A failure can only be caused by unexpected errors (eg. I/O or
276  * memory); this is no point looping on transaction failure.
277  *
278  * See Also:
279  *      tdb_transaction_prepare_commit()
280  */
281 enum TDB_ERROR tdb_transaction_commit(struct tdb_context *tdb);
282
283 /**
284  * tdb_transaction_prepare_commit - prepare to commit a transaction
285  * @tdb: the tdb context returned from tdb_open()
286  *
287  * This ensures we have the resources to commit a transaction (using
288  * tdb_transaction_commit): if this succeeds then a transaction will only
289  * fail if the write() or fsync() calls fail.
290  *
291  * See Also:
292  *      tdb_transaction_commit()
293  */
294 enum TDB_ERROR tdb_transaction_prepare_commit(struct tdb_context *tdb);
295
296 /**
297  * tdb_traverse - traverse a TDB
298  * @tdb: the tdb context returned from tdb_open()
299  * @fn: the function to call for every key/value pair (or NULL)
300  * @p: the pointer to hand to @f
301  *
302  * This walks the TDB until all they keys have been traversed, or @fn
303  * returns non-zero.  If the traverse function or other processes are
304  * changing data or adding or deleting keys, the traverse may be
305  * unreliable: keys may be skipped or (rarely) visited twice.
306  *
307  * There is one specific exception: the special case of deleting the
308  * current key does not undermine the reliability of the traversal.
309  *
310  * On success, returns the number of keys iterated.  On error returns
311  * a negative enum TDB_ERROR value.
312  */
313 #define tdb_traverse(tdb, fn, p)                                        \
314         tdb_traverse_(tdb, typesafe_cb_preargs(int, void *, (fn), (p),  \
315                                                struct tdb_context *,    \
316                                                TDB_DATA, TDB_DATA), (p))
317
318 int64_t tdb_traverse_(struct tdb_context *tdb,
319                       int (*fn)(struct tdb_context *,
320                                 TDB_DATA, TDB_DATA, void *), void *p);
321
322 /**
323  * tdb_parse_record - operate directly on data in the database.
324  * @tdb: the tdb context returned from tdb_open()
325  * @key: the key whose record we should hand to @parse
326  * @parse: the function to call for the data
327  * @data: the private pointer to hand to @parse (types must match).
328  *
329  * This avoids a copy for many cases, by handing you a pointer into
330  * the memory-mapped database.  It also locks the record to prevent
331  * other accesses at the same time.
332  *
333  * Do not alter the data handed to parse()!
334  */
335 #define tdb_parse_record(tdb, key, parse, data)                         \
336         tdb_parse_record_((tdb), (key),                                 \
337                           typesafe_cb_preargs(enum TDB_ERROR, void *,   \
338                                               (parse), (data),          \
339                                               TDB_DATA, TDB_DATA), (data))
340
341 enum TDB_ERROR tdb_parse_record_(struct tdb_context *tdb,
342                                  TDB_DATA key,
343                                  enum TDB_ERROR (*parse)(TDB_DATA k,
344                                                          TDB_DATA d,
345                                                          void *data),
346                                  void *data);
347
348 /**
349  * tdb_get_seqnum - get a database sequence number
350  * @tdb: the tdb context returned from tdb_open()
351  *
352  * This returns a sequence number: any change to the database from a
353  * tdb context opened with the TDB_SEQNUM flag will cause that number
354  * to increment.  Note that the incrementing is unreliable (it is done
355  * without locking), so this is only useful as an optimization.
356  *
357  * For example, you may have a regular database backup routine which
358  * does not operate if the sequence number is unchanged.  In the
359  * unlikely event of a failed increment, it will be backed up next
360  * time any way.
361  *
362  * Returns an enum TDB_ERROR (ie. negative) on error.
363  */
364 int64_t tdb_get_seqnum(struct tdb_context *tdb);
365
366 /**
367  * tdb_firstkey - get the "first" key in a TDB
368  * @tdb: the tdb context returned from tdb_open()
369  * @key: pointer to key.
370  *
371  * This returns an arbitrary key in the database; with tdb_nextkey() it allows
372  * open-coded traversal of the database, though it is slightly less efficient
373  * than tdb_traverse.
374  *
375  * It is your responsibility to free @key->dptr on success.
376  *
377  * Returns TDB_ERR_NOEXIST if the database is empty.
378  */
379 enum TDB_ERROR tdb_firstkey(struct tdb_context *tdb, struct tdb_data *key);
380
381 /**
382  * tdb_nextkey - get the "next" key in a TDB
383  * @tdb: the tdb context returned from tdb_open()
384  * @key: a key returned by tdb_firstkey() or tdb_nextkey().
385  *
386  * This returns another key in the database; it will free @key.dptr for
387  * your convenience.
388  *
389  * Returns TDB_ERR_NOEXIST if there are no more keys.
390  */
391 enum TDB_ERROR tdb_nextkey(struct tdb_context *tdb, struct tdb_data *key);
392
393 /**
394  * tdb_chainlock - lock a record in the TDB
395  * @tdb: the tdb context returned from tdb_open()
396  * @key: the key to lock.
397  *
398  * This prevents any access occurring to a group of keys including @key,
399  * even if @key does not exist.  This allows primitive atomic updates of
400  * records without using transactions.
401  *
402  * You cannot begin a transaction while holding a tdb_chainlock(), nor can
403  * you do any operations on any other keys in the database.  This also means
404  * that you cannot hold more than one tdb_chainlock() at a time.
405  *
406  * See Also:
407  *      tdb_chainunlock()
408  */
409 enum TDB_ERROR tdb_chainlock(struct tdb_context *tdb, TDB_DATA key);
410
411 /**
412  * tdb_chainunlock - unlock a record in the TDB
413  * @tdb: the tdb context returned from tdb_open()
414  * @key: the key to unlock.
415  *
416  * The key must have previously been locked by tdb_chainlock().
417  */
418 void tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key);
419
420 /**
421  * tdb_chainlock_read - lock a record in the TDB, for reading
422  * @tdb: the tdb context returned from tdb_open()
423  * @key: the key to lock.
424  *
425  * This prevents any changes from occurring to a group of keys including @key,
426  * even if @key does not exist.  This allows primitive atomic updates of
427  * records without using transactions.
428  *
429  * You cannot begin a transaction while holding a tdb_chainlock_read(), nor can
430  * you do any operations on any other keys in the database.  This also means
431  * that you cannot hold more than one tdb_chainlock()/read() at a time.
432  *
433  * See Also:
434  *      tdb_chainlock()
435  */
436 enum TDB_ERROR tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key);
437
438 /**
439  * tdb_chainunlock_read - unlock a record in the TDB for reading
440  * @tdb: the tdb context returned from tdb_open()
441  * @key: the key to unlock.
442  *
443  * The key must have previously been locked by tdb_chainlock_read().
444  */
445 void tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key);
446
447 /**
448  * tdb_lockall - lock the entire TDB
449  * @tdb: the tdb context returned from tdb_open()
450  *
451  * You cannot hold a tdb_chainlock while calling this.  It nests, so you
452  * must call tdb_unlockall as many times as you call tdb_lockall.
453  */
454 enum TDB_ERROR tdb_lockall(struct tdb_context *tdb);
455
456 /**
457  * tdb_unlockall - unlock the entire TDB
458  * @tdb: the tdb context returned from tdb_open()
459  */
460 void tdb_unlockall(struct tdb_context *tdb);
461
462 /**
463  * tdb_lockall_read - lock the entire TDB for reading
464  * @tdb: the tdb context returned from tdb_open()
465  *
466  * This prevents others writing to the database, eg. tdb_delete, tdb_store,
467  * tdb_append, but not tdb_fetch.
468  *
469  * You cannot hold a tdb_chainlock while calling this.  It nests, so you
470  * must call tdb_unlockall_read as many times as you call tdb_lockall_read.
471  */
472 enum TDB_ERROR tdb_lockall_read(struct tdb_context *tdb);
473
474 /**
475  * tdb_unlockall_read - unlock the entire TDB for reading
476  * @tdb: the tdb context returned from tdb_open()
477  */
478 void tdb_unlockall_read(struct tdb_context *tdb);
479
480 /**
481  * tdb_wipe_all - wipe the database clean
482  * @tdb: the tdb context returned from tdb_open()
483  *
484  * Completely erase the database.  This is faster than iterating through
485  * each key and doing tdb_delete.
486  */
487 enum TDB_ERROR tdb_wipe_all(struct tdb_context *tdb);
488
489 /**
490  * tdb_check - check a TDB for consistency
491  * @tdb: the tdb context returned from tdb_open()
492  * @check: function to check each key/data pair (or NULL)
493  * @data: argument for @check, must match type.
494  *
495  * This performs a consistency check of the open database, optionally calling
496  * a check() function on each record so you can do your own data consistency
497  * checks as well.  If check() returns an error, that is returned from
498  * tdb_check().
499  *
500  * Returns TDB_SUCCESS or an error.
501  */
502 #define tdb_check(tdb, check, data)                                     \
503         tdb_check_((tdb), typesafe_cb_preargs(enum TDB_ERROR, void *,   \
504                                               (check), (data),          \
505                                               struct tdb_data,          \
506                                               struct tdb_data),         \
507                    (data))
508
509 enum TDB_ERROR tdb_check_(struct tdb_context *tdb,
510                           enum TDB_ERROR (*check)(struct tdb_data k,
511                                                   struct tdb_data d,
512                                                   void *data),
513                           void *data);
514
515 /**
516  * tdb_error - get the last error (not threadsafe)
517  * @tdb: the tdb context returned from tdb_open()
518  *
519  * Returns the last error returned by a TDB function.
520  *
521  * This makes porting from TDB1 easier, but note that the last error is not
522  * reliable in threaded programs.
523  */
524 enum TDB_ERROR tdb_error(struct tdb_context *tdb);
525
526 /**
527  * enum tdb_summary_flags - flags for tdb_summary.
528  */
529 enum tdb_summary_flags {
530         TDB_SUMMARY_HISTOGRAMS = 1 /* Draw graphs in the summary. */
531 };
532
533 /**
534  * tdb_summary - return a string describing the TDB state
535  * @tdb: the tdb context returned from tdb_open()
536  * @flags: flags to control the summary output.
537  * @summary: pointer to string to allocate.
538  *
539  * This returns a developer-readable string describing the overall
540  * state of the tdb, such as the percentage used and sizes of records.
541  * It is designed to provide information about the tdb at a glance
542  * without displaying any keys or data in the database.
543  *
544  * On success, sets @summary to point to a malloc()'ed nul-terminated
545  * multi-line string.  It is your responsibility to free() it.
546  */
547 enum TDB_ERROR tdb_summary(struct tdb_context *tdb,
548                            enum tdb_summary_flags flags,
549                            char **summary);
550
551  
552 /**
553  * tdb_get_flags - return the flags for a tdb
554  * @tdb: the tdb context returned from tdb_open()
555  *
556  * This returns the flags on the current tdb.  Some of these are caused by
557  * the flags argument to tdb_open(), others (such as TDB_CONVERT) are
558  * intuited.
559  */
560 unsigned int tdb_get_flags(struct tdb_context *tdb);
561
562 /**
563  * tdb_add_flag - set a flag for a tdb
564  * @tdb: the tdb context returned from tdb_open()
565  * @flag: one of TDB_NOLOCK, TDB_NOMMAP or TDB_NOSYNC.
566  *
567  * You can use this to set a flag on the TDB.  You cannot set these flags
568  * on a TDB_INTERNAL tdb.
569  */
570 void tdb_add_flag(struct tdb_context *tdb, unsigned flag);
571
572 /**
573  * tdb_remove_flag - unset a flag for a tdb
574  * @tdb: the tdb context returned from tdb_open()
575  * @flag: one of TDB_NOLOCK, TDB_NOMMAP or TDB_NOSYNC.
576  *
577  * You can use this to clear a flag on the TDB.  You cannot clear flags
578  * on a TDB_INTERNAL tdb.
579  */
580 void tdb_remove_flag(struct tdb_context *tdb, unsigned flag);
581
582 /**
583  * tdb_name - get the name of a tdb
584  * @tdb: the tdb context returned from tdb_open()
585  *
586  * This returns a copy of the name string, made at tdb_open() time.  If that
587  * argument was NULL (possible for a TDB_INTERNAL db) this will return NULL.
588  *
589  * This is mostly useful for logging.
590  */
591 const char *tdb_name(const struct tdb_context *tdb);
592
593 /**
594  * tdb_fd - get the file descriptor of a tdb
595  * @tdb: the tdb context returned from tdb_open()
596  *
597  * This returns the file descriptor for the underlying database file, or -1
598  * for TDB_INTERNAL.
599  */
600 int tdb_fd(const struct tdb_context *tdb);
601
602 /**
603  * enum tdb_attribute_type - descriminator for union tdb_attribute.
604  */
605 enum tdb_attribute_type {
606         TDB_ATTRIBUTE_LOG = 0,
607         TDB_ATTRIBUTE_HASH = 1,
608         TDB_ATTRIBUTE_SEED = 2,
609         TDB_ATTRIBUTE_STATS = 3
610 };
611
612 /**
613  * struct tdb_attribute_base - common fields for all tdb attributes.
614  */
615 struct tdb_attribute_base {
616         enum tdb_attribute_type attr;
617         union tdb_attribute *next;
618 };
619
620 /**
621  * enum tdb_log_level - log levels for tdb_attribute_log
622  * @TDB_LOG_ERROR: used to log unrecoverable errors such as I/O errors
623  *                 or internal consistency failures.
624  * @TDB_LOG_USE_ERROR: used to log usage errors such as invalid parameters
625  *                 or writing to a read-only database.
626  * @TDB_LOG_WARNING: used for informational messages on issues which
627  *                   are unusual but handled by TDB internally, such
628  *                   as a failure to mmap or failure to open /dev/urandom.
629  */
630 enum tdb_log_level {
631         TDB_LOG_ERROR,
632         TDB_LOG_USE_ERROR,
633         TDB_LOG_WARNING
634 };
635
636 /**
637  * struct tdb_attribute_log - log function attribute
638  *
639  * This attribute provides a hook for you to log errors.
640  */
641 struct tdb_attribute_log {
642         struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_LOG */
643         void (*fn)(struct tdb_context *tdb,
644                    enum tdb_log_level level,
645                    const char *message,
646                    void *data);
647         void *data;
648 };
649
650 /**
651  * struct tdb_attribute_hash - hash function attribute
652  *
653  * This attribute allows you to provide an alternative hash function.
654  * This hash function will be handed keys from the database; it will also
655  * be handed the 8-byte TDB_HASH_MAGIC value for checking the header (the
656  * tdb_open() will fail if the hash value doesn't match the header).
657  *
658  * Note that if your hash function gives different results on
659  * different machine endians, your tdb will no longer work across
660  * different architectures!
661  */
662 struct tdb_attribute_hash {
663         struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_HASH */
664         uint64_t (*fn)(const void *key, size_t len, uint64_t seed,
665                        void *data);
666         void *data;
667 };
668
669 /**
670  * struct tdb_attribute_seed - hash function seed attribute
671  *
672  * The hash function seed is normally taken from /dev/urandom (or equivalent)
673  * but can be set manually here.  This is mainly for testing purposes.
674  */
675 struct tdb_attribute_seed {
676         struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_SEED */
677         uint64_t seed;
678 };
679
680 /**
681  * struct tdb_attribute_stats - tdb operational statistics
682  *
683  * This attribute records statistics of various low-level TDB operations.
684  * This can be used to assist performance evaluation.
685  *
686  * New fields will be added at the end, hence the "size" argument which
687  * indicates how large your structure is.  If your size is larger than
688  * that known about by this version of tdb, the size will be reduced to
689  * the known structure size.  Thus you can detect older versions, and
690  * thus know that newer stats will not be updated.
691  */
692 struct tdb_attribute_stats {
693         struct tdb_attribute_base base; /* .attr = TDB_ATTRIBUTE_STATS */
694         size_t size; /* = sizeof(struct tdb_attribute_stats) */
695         uint64_t allocs;
696         uint64_t   alloc_subhash;
697         uint64_t   alloc_chain;
698         uint64_t   alloc_bucket_exact;
699         uint64_t   alloc_bucket_max;
700         uint64_t   alloc_leftover;
701         uint64_t   alloc_coalesce_tried;
702         uint64_t     alloc_coalesce_lockfail;
703         uint64_t     alloc_coalesce_race;
704         uint64_t     alloc_coalesce_succeeded;
705         uint64_t        alloc_coalesce_num_merged;
706         uint64_t compares;
707         uint64_t   compare_wrong_bucket;
708         uint64_t   compare_wrong_offsetbits;
709         uint64_t   compare_wrong_keylen;
710         uint64_t   compare_wrong_rechash;
711         uint64_t   compare_wrong_keycmp;
712         uint64_t expands;
713         uint64_t frees;
714         uint64_t locks;
715         uint64_t    lock_lowlevel;
716         uint64_t    lock_nonblock;
717 };
718
719 /**
720  * union tdb_attribute - tdb attributes.
721  *
722  * This represents all the known attributes.
723  *
724  * See also:
725  *      struct tdb_attribute_log, struct tdb_attribute_hash,
726  *      struct tdb_attribute_seed, struct tdb_attribute_stats.
727  */
728 union tdb_attribute {
729         struct tdb_attribute_base base;
730         struct tdb_attribute_log log;
731         struct tdb_attribute_hash hash;
732         struct tdb_attribute_seed seed;
733         struct tdb_attribute_stats stats;
734 };
735
736 #ifdef  __cplusplus
737 }
738 #endif
739
740 #endif /* tdb2.h */