From bb5579a145cb41d3b375924d62b4ce7f655e3b1d Mon Sep 17 00:00:00 2001 From: "Bradley C. Kuszmaul" Date: Tue, 16 Apr 2013 23:59:23 -0400 Subject: [PATCH] Merge 2948 changes to main: Start putting upsert into brt layer (Refs #2948). Also add unused attributes (Closes #2950). [t:2948] close[t:2950] {{{ svn merge -c 24081 https://svn.tokutek.com/tokudb/toku/tokudb.2948 }}} . git-svn-id: file:///svn/toku/tokudb@24083 c7de825b-a66e-492c-adef-691d508d4ae1 --- newbrt/brt-internal.h | 18 ++++ newbrt/brt.c | 13 ++- newbrt/brt.h | 153 ++++++++++++++------------- newbrt/logger.c | 3 +- newbrt/recover.c | 12 ++- newbrt/tdb-recover.c | 10 +- newbrt/tests/brt-test.c | 25 +++-- newbrt/tests/brt-test1.c | 3 +- newbrt/tests/brt-test2.c | 6 +- newbrt/tests/brt-test3.c | 3 +- newbrt/tests/brt-test4.c | 3 +- newbrt/tests/brt-test5.c | 3 +- newbrt/tests/brtloader-test-writer.c | 3 +- newbrt/tests/brtloader-test.c | 2 +- newbrt/tests/test-brt-overflow.c | 3 +- newbrt/tests/test-dump-brt.c | 3 +- newbrt/tests/test1308a.c | 5 +- 17 files changed, 162 insertions(+), 106 deletions(-) diff --git a/newbrt/brt-internal.h b/newbrt/brt-internal.h index f5bfd1294af..b260431b09e 100644 --- a/newbrt/brt-internal.h +++ b/newbrt/brt-internal.h @@ -201,6 +201,24 @@ struct brt { BOOL did_set_descriptor; DESCRIPTOR_S temp_descriptor; int (*compare_fun)(DB*,const DBT*,const DBT*); + + // When an upsert message arrives it contains a key, a value (upserted_val), and an extra DBT (upserted_extra). + // If there is no such key in the database, then the upserted value is inserted. + // If there is such a key in the database, then there is associated with that key another value (prev_val). + // The system calls upsert_fun(DB, upserted_value, upserted_extra, prev_val, set_val, set_extra) + // where set_val and set_extra are provided by the system. + // The upsert_fun can look at the DBTs and the DB (to get the db descriptor) and perform one of the following actions: + // a) It can return DB_DELETE_UPSERT (which is defined in db.h). In this case, the system deletes the key-value pair. + // b) OR it can return call set_val(new_val, set_extra), + // where new_val is the dbt that was passed in. The set_val function will copy anything it needs out of new_val, so the memory pointed + // to by new_val may be stack allocated by upsert_fun (or it may be malloced, in which case upsert_fun should free that memory). + // Notes: + // 1) The DBTs passed to upsert_fun may point to memory that will be freed after the upsert_fun returns. + // 2) Furtheremore, there is likely to be some sort of lock held when upsert_fun is called. + // Those notes should not matter, since the upsert_fun should essentially be a pure function of the DBTs and DB descriptor passed in. + int (*upsert_fun)(DB*, const DBT*key, const DBT *upserted_val, const DBT *upserted_extra, const DBT *prev_val, + void (*set_val)(const DBT *new_val, void*set_extra), void *set_extra); + DB *db; // To pass to the compare fun, and close once transactions are done. OMT txns; // transactions that are using this OMT (note that the transaction checks the cf also) diff --git a/newbrt/brt.c b/newbrt/brt.c index 8888a90ad3e..9eef0977efc 100644 --- a/newbrt/brt.c +++ b/newbrt/brt.c @@ -516,7 +516,6 @@ toku_cmd_leafval_heaviside (OMTVALUE lev, void *extra) { be); } -// If you pass in data==0 then it only compares the key, not the data (even if is a DUPSORT database) static int brt_compare_pivot(BRT brt, DBT *key, bytevec ck) { @@ -2844,8 +2843,8 @@ int toku_open_brt (const char *fname, int is_create, BRT *newbrt, int nodesize, r = toku_brt_create(&brt); if (r != 0) return r; - toku_brt_set_nodesize(brt, nodesize); - toku_brt_set_bt_compare(brt, compare_fun); + r = toku_brt_set_nodesize(brt, nodesize); assert(r==0); + r = toku_brt_set_bt_compare(brt, compare_fun); assert(r==0); r = toku_brt_open(brt, fname, is_create, only_create, cachetable, txn, db); if (r != 0) { @@ -3619,7 +3618,7 @@ int toku_brt_set_flags(BRT brt, unsigned int flags) { int toku_brt_get_flags(BRT brt, unsigned int *flags) { *flags = brt->flags; - assert(brt->flags==(brt->flags&TOKU_DB_KEYCMP_BUILTIN)); // make sure there are no extranious flags + assert(brt->flags==(brt->flags&TOKU_DB_KEYCMP_BUILTIN)); // make sure there are no extraneous flags return 0; } @@ -3639,6 +3638,12 @@ int toku_brt_set_bt_compare(BRT brt, int (*bt_compare)(DB *, const DBT*, const D return 0; } +int toku_brt_set_upsert(BRT brt, int (*upsert)(DB *, const DBT *key, const DBT *upserted_val, const DBT *upserted_extra, const DBT *prev_val, + void (*set_val)(const DBT *new_val, void *set_extra), void *set_extra)) { + brt->upsert_fun = upsert; + return 0; +} + brt_compare_func toku_brt_get_bt_compare (BRT brt) { return brt->compare_fun; } diff --git a/newbrt/brt.h b/newbrt/brt.h index e70f6f1b2a7..886dbf9b41e 100644 --- a/newbrt/brt.h +++ b/newbrt/brt.h @@ -28,133 +28,136 @@ C_BEGIN //-infinity depending on direction) typedef int(*BRT_GET_CALLBACK_FUNCTION)(ITEMLEN, bytevec, ITEMLEN, bytevec, void*); -int toku_open_brt (const char *fname, int is_create, BRT *, int nodesize, CACHETABLE, TOKUTXN, int(*)(DB*,const DBT*,const DBT*), DB*); -int toku_maybe_upgrade_descriptor(BRT t, DESCRIPTOR d, BOOL do_log, TOKUTXN txn); +int toku_open_brt (const char *fname, int is_create, BRT *, int nodesize, CACHETABLE, TOKUTXN, int(*)(DB*,const DBT*,const DBT*), DB*) __attribute__ ((warn_unused_result)); +int toku_maybe_upgrade_descriptor(BRT t, DESCRIPTOR d, BOOL do_log, TOKUTXN txn) __attribute__ ((warn_unused_result)); -int toku_dictionary_redirect (const char *dst_fname_in_env, BRT old_brt, TOKUTXN txn); +int toku_dictionary_redirect (const char *dst_fname_in_env, BRT old_brt, TOKUTXN txn) __attribute__ ((warn_unused_result)); // See the brt.c file for what this toku_redirect_brt does -int toku_dictionary_redirect_abort(struct brt_header *old_h, struct brt_header *new_h, TOKUTXN txn); +int toku_dictionary_redirect_abort(struct brt_header *old_h, struct brt_header *new_h, TOKUTXN txn) __attribute__ ((warn_unused_result)); u_int32_t toku_serialize_descriptor_size(const DESCRIPTOR desc); -int toku_brt_create(BRT *); -int toku_brt_set_flags(BRT, unsigned int flags); -int toku_brt_get_flags(BRT, unsigned int *flags); -int toku_brt_set_descriptor (BRT t, u_int32_t version, const DBT* descriptor); -int toku_brt_set_nodesize(BRT, unsigned int nodesize); -int toku_brt_get_nodesize(BRT, unsigned int *nodesize); +int toku_brt_create(BRT *) __attribute__ ((warn_unused_result)); +int toku_brt_set_flags(BRT, unsigned int flags) __attribute__ ((warn_unused_result)); +int toku_brt_get_flags(BRT, unsigned int *flags) __attribute__ ((warn_unused_result)); +int toku_brt_set_descriptor (BRT t, u_int32_t version, const DBT* descriptor) __attribute__ ((warn_unused_result)); +int toku_brt_set_nodesize(BRT, unsigned int nodesize) __attribute__ ((warn_unused_result)); +int toku_brt_get_nodesize(BRT, unsigned int *nodesize) __attribute__ ((warn_unused_result)); -int toku_brt_set_bt_compare(BRT, brt_compare_func); +int toku_brt_set_bt_compare(BRT, brt_compare_func) __attribute__ ((warn_unused_result)); +int toku_brt_set_upsert(BRT brt, int (*upsert)(DB *, const DBT *key, const DBT *upserted_val, const DBT *upserted_extra, const DBT *prev_val, + void (*set_val)(const DBT *new_val, void *set_extra), void *set_extra)) + __attribute__ ((warn_unused_result)); brt_compare_func toku_brt_get_bt_compare (BRT brt); int brt_set_cachetable(BRT, CACHETABLE); int toku_brt_open(BRT, const char *fname_in_env, - int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, DB *db); + int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, DB *db) __attribute__ ((warn_unused_result)); int toku_brt_open_recovery(BRT, const char *fname_in_env, - int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, DB *db, FILENUM use_filenum); + int is_create, int only_create, CACHETABLE ct, TOKUTXN txn, DB *db, FILENUM use_filenum) __attribute__ ((warn_unused_result)); -int toku_brt_remove_subdb(BRT brt, const char *dbname, u_int32_t flags); +int toku_brt_remove_subdb(BRT brt, const char *dbname, u_int32_t flags) __attribute__ ((warn_unused_result)); -int toku_brt_broadcast_commit_all (BRT brt); -int toku_brt_lookup (BRT brt, DBT *k, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); +int toku_brt_broadcast_commit_all (BRT brt) __attribute__ ((warn_unused_result)); +int toku_brt_lookup (BRT brt, DBT *k, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); // Effect: Insert a key and data pair into a brt // Returns 0 if successful -int toku_brt_insert (BRT brt, DBT *k, DBT *v, TOKUTXN txn); +int toku_brt_insert (BRT brt, DBT *k, DBT *v, TOKUTXN txn) __attribute__ ((warn_unused_result)); -int toku_brt_optimize (BRT brt); +int toku_brt_optimize (BRT brt) __attribute__ ((warn_unused_result)); // Effect: Insert a key and data pair into a brt if the oplsn is newer than the brt lsn. This function is called during recovery. // Returns 0 if successful -int toku_brt_maybe_insert (BRT brt, DBT *k, DBT *v, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn, int do_logging, enum brt_msg_type type); -int toku_brt_load_recovery(TOKUTXN txn, char const * old_iname, char const * new_iname, int do_fsync, int do_log, LSN *load_lsn); -int toku_brt_load(BRT brt, TOKUTXN txn, char const * new_iname, int do_fsync, LSN *get_lsn); -int toku_brt_log_put_multiple (TOKUTXN txn, BRT src_brt, BRT *brts, int num_brts, const DBT *key, const DBT *val); -int toku_brt_log_del_multiple (TOKUTXN txn, BRT src_brt, BRT *brts, int num_brts, const DBT *key, const DBT *val); +int toku_brt_maybe_insert (BRT brt, DBT *k, DBT *v, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn, int do_logging, enum brt_msg_type type) __attribute__ ((warn_unused_result)); +int toku_brt_load_recovery(TOKUTXN txn, char const * old_iname, char const * new_iname, int do_fsync, int do_log, LSN *load_lsn) __attribute__ ((warn_unused_result)); +int toku_brt_load(BRT brt, TOKUTXN txn, char const * new_iname, int do_fsync, LSN *get_lsn) __attribute__ ((warn_unused_result)); +int toku_brt_log_put_multiple (TOKUTXN txn, BRT src_brt, BRT *brts, int num_brts, const DBT *key, const DBT *val) __attribute__ ((warn_unused_result)); +int toku_brt_log_del_multiple (TOKUTXN txn, BRT src_brt, BRT *brts, int num_brts, const DBT *key, const DBT *val) __attribute__ ((warn_unused_result)); // Effect: Delete a key from a brt // Returns 0 if successful -int toku_brt_delete (BRT brt, DBT *k, TOKUTXN txn); +int toku_brt_delete (BRT brt, DBT *k, TOKUTXN txn) __attribute__ ((warn_unused_result)); // Effect: Delete a key from a brt if the oplsn is newer than the brt lsn. This function is called during recovery. // Returns 0 if successful -int toku_brt_maybe_delete (BRT brt, DBT *k, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn, int do_logging); +int toku_brt_maybe_delete (BRT brt, DBT *k, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn, int do_logging) __attribute__ ((warn_unused_result)); // Effect: Delete a pair only if both k and v are equal according to the comparison function. // Returns 0 if successful -int toku_brt_delete_both (BRT brt, DBT *k, DBT *v, TOKUTXN txn); +int toku_brt_delete_both (BRT brt, DBT *k, DBT *v, TOKUTXN txn) __attribute__ ((warn_unused_result)); // Effect: Delete a pair only if both k and v are equal according to the comparison function and the // oplsn is newer than the brt lsn. This function is called by recovery. // Returns 0 if successful -int toku_brt_maybe_delete_both (BRT brt, DBT *k, DBT *v, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn); +int toku_brt_maybe_delete_both (BRT brt, DBT *k, DBT *v, TOKUTXN txn, BOOL oplsn_valid, LSN oplsn) __attribute__ ((warn_unused_result)); -int toku_brt_db_delay_closed (BRT brt, DB* db, int (*close_db)(DB*, u_int32_t), u_int32_t close_flags); -int toku_close_brt (BRT, char **error_string); -int toku_close_brt_lsn (BRT brt, char **error_string, BOOL oplsn_valid, LSN oplsn); +int toku_brt_db_delay_closed (BRT brt, DB* db, int (*close_db)(DB*, u_int32_t), u_int32_t close_flags) __attribute__ ((warn_unused_result)); +int toku_close_brt (BRT, char **error_string) __attribute__ ((warn_unused_result)); +int toku_close_brt_lsn (BRT brt, char **error_string, BOOL oplsn_valid, LSN oplsn) __attribute__ ((warn_unused_result)); -int toku_brt_set_panic(BRT brt, int panic, char *panic_string); +int toku_brt_set_panic(BRT brt, int panic, char *panic_string) __attribute__ ((warn_unused_result)); -int toku_dump_brt (FILE *,BRT brt); +int toku_dump_brt (FILE *,BRT brt) __attribute__ ((warn_unused_result)); void brt_fsync (BRT); /* fsync, but don't clear the caches. */ void brt_flush (BRT); /* fsync and clear the caches. */ -int toku_brt_get_cursor_count (BRT brt); +int toku_brt_get_cursor_count (BRT brt) __attribute__ ((warn_unused_result)); // get the number of cursors in the tree // returns: the number of cursors. // asserts: the number of cursors >= 0. -int toku_brt_flush (BRT brt); +int toku_brt_flush (BRT brt) __attribute__ ((warn_unused_result)); // effect: the tree's cachefile is flushed // returns: 0 if success -int toku_brt_truncate (BRT brt); +int toku_brt_truncate (BRT brt) __attribute__ ((warn_unused_result)); // effect: remove everything from the tree // returns: 0 if success -LSN toku_brt_checkpoint_lsn(BRT brt); +LSN toku_brt_checkpoint_lsn(BRT brt) __attribute__ ((warn_unused_result)); // create and initialize a cache table // cachesize is the upper limit on the size of the size of the values in the table // pass 0 if you want the default -int toku_brt_create_cachetable(CACHETABLE *t, long cachesize, LSN initial_lsn, TOKULOGGER); +int toku_brt_create_cachetable(CACHETABLE *t, long cachesize, LSN initial_lsn, TOKULOGGER) __attribute__ ((warn_unused_result)); extern int toku_brt_debug_mode; -int toku_verify_brt (BRT brt); +int toku_verify_brt (BRT brt) __attribute__ ((warn_unused_result)); //int show_brt_blocknumbers(BRT); typedef struct brt_cursor *BRT_CURSOR; -int toku_brt_cursor (BRT, BRT_CURSOR*, TOKUTXN, BOOL); +int toku_brt_cursor (BRT, BRT_CURSOR*, TOKUTXN, BOOL) __attribute__ ((warn_unused_result)); // get is deprecated in favor of the individual functions below -int toku_brt_cursor_get (BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v, int get_flags); +int toku_brt_cursor_get (BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v, int get_flags) __attribute__ ((warn_unused_result)); -int toku_brt_flatten(BRT, TOKUTXN ttxn); -int toku_brt_cursor_first(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_last(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_next(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_next_nodup(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_prev(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_prev_nodup(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_current(BRT_CURSOR cursor, int op, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_set(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_set_range(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_set_range_reverse(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_get_both_range(BRT_CURSOR cursor, DBT *key, DBT *val, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); -int toku_brt_cursor_get_both_range_reverse(BRT_CURSOR cursor, DBT *key, DBT *val, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v); +int toku_brt_flatten(BRT, TOKUTXN ttxn) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_first(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_last(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_next(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_next_nodup(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_prev(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_prev_nodup(BRT_CURSOR cursor, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_current(BRT_CURSOR cursor, int op, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_set(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_set_range(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_set_range_reverse(BRT_CURSOR cursor, DBT *key, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_get_both_range(BRT_CURSOR cursor, DBT *key, DBT *val, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_get_both_range_reverse(BRT_CURSOR cursor, DBT *key, DBT *val, BRT_GET_CALLBACK_FUNCTION getf, void *getf_v) __attribute__ ((warn_unused_result)); -int toku_brt_cursor_delete(BRT_CURSOR cursor, int flags, TOKUTXN); -int toku_brt_cursor_close (BRT_CURSOR curs); -BOOL toku_brt_cursor_uninitialized(BRT_CURSOR c); +int toku_brt_cursor_delete(BRT_CURSOR cursor, int flags, TOKUTXN) __attribute__ ((warn_unused_result)); +int toku_brt_cursor_close (BRT_CURSOR curs) __attribute__ ((warn_unused_result)); +BOOL toku_brt_cursor_uninitialized(BRT_CURSOR c) __attribute__ ((warn_unused_result)); void toku_brt_cursor_peek(BRT_CURSOR cursor, const DBT **pkey, const DBT **pval); typedef struct brtenv *BRTENV; -int brtenv_checkpoint (BRTENV env); +int brtenv_checkpoint (BRTENV env) __attribute__ ((warn_unused_result)); extern int toku_brt_do_push_cmd; // control whether push occurs eagerly. @@ -163,7 +166,7 @@ int toku_brt_dbt_set(DBT* key, DBT* key_source); DICTIONARY_ID toku_brt_get_dictionary_id(BRT); -int toku_brt_height_of_root(BRT, int *height); // for an open brt, return the current height. +int toku_brt_height_of_root(BRT, int *height) __attribute__ ((warn_unused_result)); // for an open brt, return the current height. enum brt_header_flags { //TOKU_DB_DUP = (1<<0), //Obsolete #2862 @@ -172,7 +175,7 @@ enum brt_header_flags { //TOKU_DB_VALCMP_BUILTIN = (1<<3), }; -int toku_brt_keyrange (BRT brt, DBT *key, u_int64_t *less, u_int64_t *equal, u_int64_t *greater); +int toku_brt_keyrange (BRT brt, DBT *key, u_int64_t *less, u_int64_t *equal, u_int64_t *greater) __attribute__ ((warn_unused_result)); struct brtstat64_s { u_int64_t nkeys; /* estimate how many unique keys (even when flattened this may be an estimate) */ u_int64_t ndata; /* estimate the number of pairs (exact when flattened and committed) */ @@ -182,21 +185,23 @@ struct brtstat64_s { }; int toku_brt_stat64 (BRT, TOKUTXN, struct brtstat64_s *stat - ); + ) + __attribute__ ((warn_unused_result)); int toku_brt_init(void (*ydb_lock_callback)(void), void (*ydb_unlock_callback)(void), - void (*db_set_brt)(DB*,BRT)); -int toku_brt_destroy(void); -int toku_pwrite_lock_init(void); -int toku_pwrite_lock_destroy(void); -int toku_brt_serialize_init(void); -int toku_brt_serialize_destroy(void); + void (*db_set_brt)(DB*,BRT)) + __attribute__ ((warn_unused_result)); +int toku_brt_destroy(void) __attribute__ ((warn_unused_result)); +int toku_pwrite_lock_init(void) __attribute__ ((warn_unused_result)); +int toku_pwrite_lock_destroy(void) __attribute__ ((warn_unused_result)); +int toku_brt_serialize_init(void) __attribute__ ((warn_unused_result)); +int toku_brt_serialize_destroy(void) __attribute__ ((warn_unused_result)); void toku_maybe_truncate_cachefile (CACHEFILE cf, int fd, u_int64_t size_used); // Effect: truncate file if overallocated by at least 32MiB -int maybe_preallocate_in_file (int fd, u_int64_t size); +int maybe_preallocate_in_file (int fd, u_int64_t size) __attribute__ ((warn_unused_result)); // Effect: If file size is less than SIZE, make it bigger by either doubling it or growing by 16MB whichever is less. void toku_brt_header_suppress_rollbacks(struct brt_header *h, TOKUTXN txn); @@ -208,22 +213,22 @@ void toku_brt_suppress_recovery_logs (BRT brt, TOKUTXN txn); // implies: txnid_that_created_or_locked_when_empty matches txn // implies: toku_txn_note_brt(brt, txn) has been called -int toku_brt_zombie_needed (BRT brt); +int toku_brt_zombie_needed (BRT brt) __attribute__ ((warn_unused_result)); -int toku_brt_get_fragmentation(BRT brt, TOKU_DB_FRAGMENTATION report); -int toku_brt_header_set_panic(struct brt_header *h, int panic, char *panic_string); +int toku_brt_get_fragmentation(BRT brt, TOKU_DB_FRAGMENTATION report) __attribute__ ((warn_unused_result)); +int toku_brt_header_set_panic(struct brt_header *h, int panic, char *panic_string) __attribute__ ((warn_unused_result)); -BOOL toku_brt_is_empty (BRT brt, BOOL *try_again); +BOOL toku_brt_is_empty (BRT brt, BOOL *try_again) __attribute__ ((warn_unused_result)); // Effect: Return TRUE iff the tree is empty. (However if *try_again is set to TRUE by toku_brt_is_empty, then the answer is inconclusive, and the function should // be tried again. It's a good idea to release the big ydb lock in this case. -BOOL toku_brt_is_empty_fast (BRT brt); +BOOL toku_brt_is_empty_fast (BRT brt) __attribute__ ((warn_unused_result)); // Effect: Return TRUE if there are no messages or leaf entries in the tree. If so, it's empty. If there are messages or leaf entries, we say it's not empty // even though if we were to optimize the tree it might turn out that they are empty. -double get_tdiff(void) __attribute__((__visibility__("default"))); +double get_tdiff(void) __attribute__((__visibility__("default"))) __attribute__ ((warn_unused_result)); -BOOL toku_brt_is_recovery_logging_suppressed (BRT); +BOOL toku_brt_is_recovery_logging_suppressed (BRT) __attribute__ ((warn_unused_result)); //TODO: #1485 once we have multiple main threads, restore this code, analyze performance. #ifndef TOKU_MULTIPLE_MAIN_THREADS #define TOKU_MULTIPLE_MAIN_THREADS 0 diff --git a/newbrt/logger.c b/newbrt/logger.c index 27764308cd6..ad75cf376f0 100644 --- a/newbrt/logger.c +++ b/newbrt/logger.c @@ -201,7 +201,8 @@ toku_logger_close_rollback(TOKULOGGER logger, BOOL recovery_failed) { struct brt_header *h = toku_cachefile_get_userdata(cf); toku_brtheader_lock(h); if (!h->panic && recovery_failed) { - toku_brt_header_set_panic(h, EINVAL, "Recovery failed"); + r = toku_brt_header_set_panic(h, EINVAL, "Recovery failed"); + assert(r==0); } //Verify it is safe to close it. if (!h->panic) { //If paniced, it is safe to close. diff --git a/newbrt/recover.c b/newbrt/recover.c index 5590b09a7da..8a1a2f474be 100644 --- a/newbrt/recover.c +++ b/newbrt/recover.c @@ -107,7 +107,8 @@ static void file_map_close_dictionaries(struct file_map *fmap, BOOL recovery_suc assert(tuple->brt); if (!recovery_succeeded) { // don't update the brt on close - toku_brt_set_panic(tuple->brt, DB_RUNRECOVERY, "recovery failed"); + r = toku_brt_set_panic(tuple->brt, DB_RUNRECOVERY, "recovery failed"); + assert(r==0); } //Logging is already back on. No need to pass LSN into close. char *error_string = NULL; @@ -245,11 +246,14 @@ static int internal_recover_fopen_or_fcreate (RECOVER_ENV renv, BOOL must_create r = toku_brt_create(&brt); assert(r == 0); - toku_brt_set_flags(brt, treeflags); + r = toku_brt_set_flags(brt, treeflags); + assert(r==0); // set the key compare functions - if (!(treeflags & TOKU_DB_KEYCMP_BUILTIN) && renv->bt_compare) - toku_brt_set_bt_compare(brt, renv->bt_compare); + if (!(treeflags & TOKU_DB_KEYCMP_BUILTIN) && renv->bt_compare) { + r = toku_brt_set_bt_compare(brt, renv->bt_compare); + assert(r==0); + } // TODO mode (FUTURE FEATURE) mode = mode; diff --git a/newbrt/tdb-recover.c b/newbrt/tdb-recover.c index c7f3e767287..e7919076f1f 100644 --- a/newbrt/tdb-recover.c +++ b/newbrt/tdb-recover.c @@ -18,9 +18,15 @@ static void dummy_set_brt(DB *db UU(), BRT brt UU()) {} int main(int argc, const char *const argv[]) { - toku_brt_init(dummy, dummy, dummy_set_brt); + { + int rr = toku_brt_init(dummy, dummy, dummy_set_brt); + assert(rr==0); + } int r = recovery_main(argc, argv); - toku_brt_destroy(); + { + int rr = toku_brt_destroy(); + assert(rr=0); + } return r; } diff --git a/newbrt/tests/brt-test.c b/newbrt/tests/brt-test.c index 37fd9f5465a..8e4d413c826 100644 --- a/newbrt/tests/brt-test.c +++ b/newbrt/tests/brt-test.c @@ -19,7 +19,7 @@ static void test_dump_empty_db (void) { unlink(fname); r = toku_open_brt(fname, 1, &t, 1024, ct, null_txn, toku_builtin_compare_fun, null_db); assert(r==0); - if (verbose) toku_dump_brt(stdout, t); + if (verbose) { r=toku_dump_brt(stdout, t); assert(r==0); } r = toku_close_brt(t, 0); assert(r==0); r = toku_cachetable_close(&ct); assert(r==0); @@ -44,15 +44,15 @@ static void test_multiple_files_of_size (int size) { DBT k,v; snprintf(key, 100, "key%d", i); snprintf(val, 100, "val%d", i); - toku_brt_insert(t0, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v, val, 1+strlen(val)), null_txn); + r = toku_brt_insert(t0, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v, val, 1+strlen(val)), null_txn); assert(r==0); snprintf(val, 100, "Val%d", i); - toku_brt_insert(t1, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v, val, 1+strlen(val)), null_txn); + r = toku_brt_insert(t1, toku_fill_dbt(&k, key, 1+strlen(key)), toku_fill_dbt(&v, val, 1+strlen(val)), null_txn); assert(r==0); } //toku_verify_brt(t0); //dump_brt(t0); //dump_brt(t1); - toku_verify_brt(t0); - toku_verify_brt(t1); + r = toku_verify_brt(t0); assert(r==0); + r = toku_verify_brt(t1); assert(r==0); r = toku_close_brt(t0, 0); assert(r==0); r = toku_close_brt(t1, 0); assert(r==0); @@ -105,7 +105,8 @@ static void test_multiple_brts_one_db_one_file (void) { DBT kb, vb; snprintf(k, 20, "key%d", i); snprintf(v, 20, "val%d", i); - toku_brt_insert(trees[i], toku_fill_dbt(&kb, k, strlen(k)+1), toku_fill_dbt(&vb, v, strlen(v)+1), null_txn); + r = toku_brt_insert(trees[i], toku_fill_dbt(&kb, k, strlen(k)+1), toku_fill_dbt(&vb, v, strlen(v)+1), null_txn); + assert(r==0); } for (i=0; i