[t:4927], remove tabs from files in src

git-svn-id: file:///svn/toku/tokudb@43841 c7de825b-a66e-492c-adef-691d508d4ae1

src/indexer.c

@@ -35,9 +35,9 @@
 static INDEXER_STATUS_S indexer_status;
 
 #define STATUS_INIT(k,t,l) { \
-	indexer_status.status[k].keyname = #k; \
-	indexer_status.status[k].type    = t;  \
-	indexer_status.status[k].legend  = "indexer: " l; \
+        indexer_status.status[k].keyname = #k; \
+        indexer_status.status[k].type    = t;  \
+        indexer_status.status[k].legend  = "indexer: " l; \
     }
 
 static void
@@ -60,7 +60,7 @@ status_init(void) {
 void
 toku_indexer_get_status(INDEXER_STATUS statp) {
     if (!indexer_status.initialized)
-	status_init();
+        status_init();
     *statp = indexer_status;
 }
 
@@ -84,14 +84,14 @@ static int
 associate_indexer_with_hot_dbs(DB_INDEXER *indexer, DB *dest_dbs[], int N) {
     int result =0;
     for (int i = 0; i < N; i++) {
-	result = toku_db_set_indexer(dest_dbs[i], indexer);
-	if (result != 0) {
-	    for (int j = 0; j < i; j++) {
-		int result2 = toku_db_set_indexer(dest_dbs[j], NULL);
-		lazy_assert(result2 == 0);
-	    }
+        result = toku_db_set_indexer(dest_dbs[i], indexer);
+        if (result != 0) {
+            for (int j = 0; j < i; j++) {
+                int result2 = toku_db_set_indexer(dest_dbs[j], NULL);
+                lazy_assert(result2 == 0);
+            }
             break;
-	}
+        }
     }
     return result;
 }
@@ -99,8 +99,8 @@ associate_indexer_with_hot_dbs(DB_INDEXER *indexer, DB *dest_dbs[], int N) {
 static void
 disassociate_indexer_from_hot_dbs(DB_INDEXER *indexer) {
     for (int i = 0; i < indexer->i->N; i++) {
-	int result = toku_db_set_indexer(indexer->i->dest_dbs[i], NULL);
-	lazy_assert(result == 0);
+        int result = toku_db_set_indexer(indexer->i->dest_dbs[i], NULL);
+        lazy_assert(result == 0);
     }
 }
 
@@ -215,13 +215,13 @@ create_exit:
         
         *indexerp = indexer;
 
-	(void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CREATE), 1);
-	(void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CURRENT), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CREATE), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CURRENT), 1);
         if ( STATUS_VALUE(INDEXER_CURRENT) > STATUS_VALUE(INDEXER_MAX) )
-	    STATUS_VALUE(INDEXER_MAX) = STATUS_VALUE(INDEXER_CURRENT);   // NOT WORTH A LOCK TO MAKE THREADSAFE), may be inaccurate
+            STATUS_VALUE(INDEXER_MAX) = STATUS_VALUE(INDEXER_CURRENT);   // NOT WORTH A LOCK TO MAKE THREADSAFE), may be inaccurate
         
     } else {
-	(void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CREATE_FAIL), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CREATE_FAIL), 1);
         free_indexer(indexer);
     }
 
@@ -271,11 +271,11 @@ build_index(DB_INDEXER *indexer) {
         toku_ydb_lock();
 
         result = le_cursor_next(indexer->i->lec, &le);
-	if (result != 0) {
-	    done = TRUE;
-	    if (result == DB_NOTFOUND)
-		result = 0;  // all done, normal way to exit loop successfully
-	}
+        if (result != 0) {
+            done = TRUE;
+            if (result == DB_NOTFOUND)
+                result = 0;  // all done, normal way to exit loop successfully
+        }
         else {
             // this code may be faster ule malloc/free is not done every time
             ULEHANDLE ule = toku_ule_create(le.data);
@@ -297,8 +297,8 @@ build_index(DB_INDEXER *indexer) {
         
         if (result == 0) 
             result = maybe_call_poll_func(indexer, loop_count);
-	if (result != 0)
-	    done = TRUE;
+        if (result != 0)
+            done = TRUE;
     }
 
     toku_destroy_dbt(&key);
@@ -312,7 +312,7 @@ build_index(DB_INDEXER *indexer) {
     if ( result == 0 ) {
         (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_BUILD), 1);
     } else {
-	(void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_BUILD_FAIL), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_BUILD_FAIL), 1);
     }
 
 
@@ -349,7 +349,7 @@ close_indexer(DB_INDEXER *indexer) {
     if ( r == 0 ) {
         (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CLOSE), 1);
     } else {
-	(void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CLOSE_FAIL), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(INDEXER_CLOSE_FAIL), 1);
     }
     return r;
 }

src/loader.c

@@ -43,9 +43,9 @@ enum {MAX_FILE_SIZE=256};
 static LOADER_STATUS_S loader_status;
 
 #define STATUS_INIT(k,t,l) { \
-	loader_status.status[k].keyname = #k; \
-	loader_status.status[k].type    = t;  \
-	loader_status.status[k].legend  = "loader: " l; \
+        loader_status.status[k].keyname = #k; \
+        loader_status.status[k].type    = t;  \
+        loader_status.status[k].legend  = "loader: " l; \
     }
 
 static void
@@ -68,7 +68,7 @@ status_init(void) {
 void
 toku_loader_get_status(LOADER_STATUS statp) {
     if (!loader_status.initialized)
-	status_init();
+        status_init();
     *statp = loader_status;
 }
 
@@ -338,7 +338,7 @@ int toku_loader_create_loader(DB_ENV *env,
 
 int toku_loader_set_poll_function(DB_LOADER *loader,
                                   int (*poll_func)(void *extra, float progress),
-				  void *poll_extra) 
+                                  void *poll_extra) 
 {
     invariant(loader != NULL);
     loader->i->poll_func = poll_func;
@@ -348,7 +348,7 @@ int toku_loader_set_poll_function(DB_LOADER *loader,
 
 int toku_loader_set_error_callback(DB_LOADER *loader, 
                                    void (*error_cb)(DB *db, int i, int err, DBT *key, DBT *val, void *extra),
-				   void *error_extra) 
+                                   void *error_extra) 
 {
     invariant(loader != NULL);
     loader->i->error_callback = error_cb;
@@ -367,7 +367,7 @@ int toku_loader_put(DB_LOADER *loader, DBT *key, DBT *val)
     // skip put if error already found
     if ( loader->i->err_errno != 0 ) {
         r = -1;
-	goto cleanup;
+        goto cleanup;
     }
 
     if (loader->i->loader_flags & LOADER_USE_PUTS) {
@@ -407,9 +407,9 @@ int toku_loader_put(DB_LOADER *loader, DBT *key, DBT *val)
     }
  cleanup:
     if (r==0)
-	STATUS_VALUE(LOADER_PUT)++;  // executed too often to be worth making threadsafe
+        STATUS_VALUE(LOADER_PUT)++;  // executed too often to be worth making threadsafe
     else
-	STATUS_VALUE(LOADER_PUT_FAIL)++;
+        STATUS_VALUE(LOADER_PUT_FAIL)++;
     return r;
 }
 
@@ -437,9 +437,9 @@ int toku_loader_close(DB_LOADER *loader)
     free_loader(loader);
     toku_ydb_unlock();
     if (r==0)
-	(void) __sync_fetch_and_add(&STATUS_VALUE(LOADER_CLOSE), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(LOADER_CLOSE), 1);
     else
-	(void) __sync_fetch_and_add(&STATUS_VALUE(LOADER_CLOSE_FAIL), 1);
+        (void) __sync_fetch_and_add(&STATUS_VALUE(LOADER_CLOSE_FAIL), 1);
     return r;
 }
 

src/ydb.c

@@ -60,9 +60,9 @@ static int env_is_panicked = 0;
 void
 env_panic(DB_ENV * env, int cause, char * msg) {
     if (cause == 0)
-	cause = -1;  // if unknown cause, at least guarantee panic
+        cause = -1;  // if unknown cause, at least guarantee panic
     if (msg == NULL)
-	msg = "Unknown cause in env_panic\n";
+        msg = "Unknown cause in env_panic\n";
     env_is_panicked = cause;
     env->i->is_panicked = cause;
     env->i->panic_string = toku_strdup(msg);
@@ -103,9 +103,9 @@ static YDB_LAYER_STATUS_S ydb_layer_status;
 #define STATUS_VALUE(x) ydb_layer_status.status[x].value.num
 
 #define STATUS_INIT(k,t,l) { \
-	ydb_layer_status.status[k].keyname = #k; \
-	ydb_layer_status.status[k].type    = t;  \
-	ydb_layer_status.status[k].legend  = l; \
+        ydb_layer_status.status[k].keyname = #k; \
+        ydb_layer_status.status[k].type    = t;  \
+        ydb_layer_status.status[k].legend  = l; \
     }
 static void
 ydb_layer_status_init (void) {
@@ -297,34 +297,34 @@ env_fs_poller(void *arg) {
     switch (env->i->fs_state) {
     case FS_RED:
         if (!in_red) {
-	    if (in_yellow) {
-		env->i->fs_state = FS_YELLOW;
-	    } else {
-		env->i->fs_state = FS_GREEN;
-	    }
-	}
+            if (in_yellow) {
+                env->i->fs_state = FS_YELLOW;
+            } else {
+                env->i->fs_state = FS_GREEN;
+            }
+        }
         break;
     case FS_YELLOW:
         if (in_red) {
-	    if ((now - env->i->last_seq_entered_red > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
-		env_fs_report_in_red(env);
+            if ((now - env->i->last_seq_entered_red > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
+                env_fs_report_in_red(env);
             env->i->fs_state = FS_RED;
-	    env->i->last_seq_entered_red = now;
+            env->i->last_seq_entered_red = now;
         } else if (!in_yellow) {
             env->i->fs_state = FS_GREEN;
         }
         break;
     case FS_GREEN:
         if (in_red) {
-	    if ((now - env->i->last_seq_entered_red > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
-		env_fs_report_in_red(env);
+            if ((now - env->i->last_seq_entered_red > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
+                env_fs_report_in_red(env);
             env->i->fs_state = FS_RED;
-	    env->i->last_seq_entered_red = now;
+            env->i->last_seq_entered_red = now;
         } else if (in_yellow) {
-	    if ((now - env->i->last_seq_entered_yellow > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
-		env_fs_report_in_yellow(env);
+            if ((now - env->i->last_seq_entered_yellow > ZONEREPORTLIMIT) || (now < ZONEREPORTLIMIT))
+                env_fs_report_in_yellow(env);
             env->i->fs_state = FS_YELLOW;
-	    env->i->last_seq_entered_yellow = now;
+            env->i->last_seq_entered_yellow = now;
         }
         break;
     default:
@@ -368,7 +368,7 @@ env_setup_real_dir(DB_ENV *env, char **real_dir, const char *nominal_dir) {
 
     assert(env->i->dir);
     if (nominal_dir) 
-	*real_dir = toku_construct_full_name(2, env->i->dir, nominal_dir);
+        *real_dir = toku_construct_full_name(2, env->i->dir, nominal_dir);
     else
         *real_dir = toku_strdup(env->i->dir);
 }
@@ -398,9 +398,9 @@ ydb_do_recovery (DB_ENV *env) {
     assert(env->i->real_log_dir);
     toku_ydb_unlock();
     int r = tokudb_recover(env,
-			   toku_keep_prepared_txn_callback,
-			   keep_cachetable_callback,
-			   env->i->logger,
+                           toku_keep_prepared_txn_callback,
+                           keep_cachetable_callback,
+                           env->i->logger,
                            env->i->dir, env->i->real_log_dir, env->i->bt_compare,
                            env->i->update_function,
                            env->i->generate_row_for_put, env->i->generate_row_for_del,
@@ -476,9 +476,9 @@ typedef struct {
 static PERSISTENT_UPGRADE_STATUS_S persistent_upgrade_status;
 
 #define PERSISTENT_UPGRADE_STATUS_INIT(k,t,l) { \
-	persistent_upgrade_status.status[k].keyname = #k; \
-	persistent_upgrade_status.status[k].type    = t;  \
-	persistent_upgrade_status.status[k].legend  = "upgrade: " l; \
+        persistent_upgrade_status.status[k].keyname = #k; \
+        persistent_upgrade_status.status[k].type    = t;  \
+        persistent_upgrade_status.status[k].legend  = "upgrade: " l; \
     }
 
 static void
@@ -520,9 +520,9 @@ maybe_upgrade_persistent_environment_dictionary(DB_ENV * env, DB_TXN * txn, LSN
     uint32_t stored_env_version = toku_dtoh32(*(uint32_t*)val.data);
     PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_STORED_ENV_VERSION_AT_STARTUP) = stored_env_version;
     if (stored_env_version > FT_LAYOUT_VERSION)
-	r = TOKUDB_DICTIONARY_TOO_NEW;
+        r = TOKUDB_DICTIONARY_TOO_NEW;
     else if (stored_env_version < FT_LAYOUT_MIN_SUPPORTED_VERSION)
-	r = TOKUDB_DICTIONARY_TOO_OLD;
+        r = TOKUDB_DICTIONARY_TOO_OLD;
     else if (stored_env_version < FT_LAYOUT_VERSION) {
         const uint32_t curr_env_ver_d = toku_htod32(FT_LAYOUT_VERSION);
         toku_fill_dbt(&key, curr_env_ver_key, strlen(curr_env_ver_key));
@@ -533,22 +533,22 @@ maybe_upgrade_persistent_environment_dictionary(DB_ENV * env, DB_TXN * txn, LSN
         // although the variable name is last_lsn_of_v13, this key really represents
         // the last lsn of whatever we upgraded from, may be be v13 or 14, or in the
         // future, something else
-	uint64_t last_lsn_of_v13_d = toku_htod64(last_lsn_of_clean_shutdown_read_from_log.lsn);
-	toku_fill_dbt(&key, last_lsn_of_v13_key, strlen(last_lsn_of_v13_key));
-	toku_fill_dbt(&val, &last_lsn_of_v13_d, sizeof(last_lsn_of_v13_d));
-	r = toku_db_put(persistent_environment, txn, &key, &val, 0, TRUE);
+        uint64_t last_lsn_of_v13_d = toku_htod64(last_lsn_of_clean_shutdown_read_from_log.lsn);
+        toku_fill_dbt(&key, last_lsn_of_v13_key, strlen(last_lsn_of_v13_key));
+        toku_fill_dbt(&val, &last_lsn_of_v13_d, sizeof(last_lsn_of_v13_d));
+        r = toku_db_put(persistent_environment, txn, &key, &val, 0, TRUE);
         assert_zero(r);
-	
-	time_t upgrade_v19_time_d = toku_htod64(time(NULL));
-	toku_fill_dbt(&key, upgrade_v19_time_key, strlen(upgrade_v19_time_key));
-	toku_fill_dbt(&val, &upgrade_v19_time_d, sizeof(upgrade_v19_time_d));
-	r = toku_db_put(persistent_environment, txn, &key, &val, DB_NOOVERWRITE, TRUE);
+        
+        time_t upgrade_v19_time_d = toku_htod64(time(NULL));
+        toku_fill_dbt(&key, upgrade_v19_time_key, strlen(upgrade_v19_time_key));
+        toku_fill_dbt(&val, &upgrade_v19_time_d, sizeof(upgrade_v19_time_d));
+        r = toku_db_put(persistent_environment, txn, &key, &val, DB_NOOVERWRITE, TRUE);
         assert_zero(r);
 
-	uint64_t upgrade_v19_footprint_d = toku_htod64(toku_log_upgrade_get_footprint());
-	toku_fill_dbt(&key, upgrade_v19_footprint_key, strlen(upgrade_v19_footprint_key));
-	toku_fill_dbt(&val, &upgrade_v19_footprint_d, sizeof(upgrade_v19_footprint_d));
-	r = toku_db_put(persistent_environment, txn, &key, &val, DB_NOOVERWRITE, TRUE);
+        uint64_t upgrade_v19_footprint_d = toku_htod64(toku_log_upgrade_get_footprint());
+        toku_fill_dbt(&key, upgrade_v19_footprint_key, strlen(upgrade_v19_footprint_key));
+        toku_fill_dbt(&val, &upgrade_v19_footprint_d, sizeof(upgrade_v19_footprint_d));
+        r = toku_db_put(persistent_environment, txn, &key, &val, DB_NOOVERWRITE, TRUE);
         assert_zero(r);
     }
     return r;
@@ -579,33 +579,33 @@ capture_persistent_env_contents (DB_ENV * env, DB_TXN * txn) {
 
     // make no assertions about timestamps, clock may have been reset
     if (persistent_original_env_version >= FT_LAYOUT_VERSION_14) {
-	toku_fill_dbt(&key, creation_time_key, strlen(creation_time_key));
-	toku_init_dbt(&val);
-	r = toku_db_get(persistent_environment, txn, &key, &val, 0);
-	assert(r == 0);
-	STATUS_VALUE(YDB_LAYER_TIME_CREATION) = toku_dtoh64((*(time_t*)val.data));
+        toku_fill_dbt(&key, creation_time_key, strlen(creation_time_key));
+        toku_init_dbt(&val);
+        r = toku_db_get(persistent_environment, txn, &key, &val, 0);
+        assert(r == 0);
+        STATUS_VALUE(YDB_LAYER_TIME_CREATION) = toku_dtoh64((*(time_t*)val.data));
     }
 
     if (persistent_original_env_version != curr_env_version) {
-	// an upgrade was performed at some time, capture info about the upgrade
-	
-	toku_fill_dbt(&key, last_lsn_of_v13_key, strlen(last_lsn_of_v13_key));
-	toku_init_dbt(&val);
-	r = toku_db_get(persistent_environment, txn, &key, &val, 0);
-	assert(r == 0);
-	PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_LAST_LSN_OF_V13) = toku_dtoh64(*(uint32_t*)val.data);
+        // an upgrade was performed at some time, capture info about the upgrade
+        
+        toku_fill_dbt(&key, last_lsn_of_v13_key, strlen(last_lsn_of_v13_key));
+        toku_init_dbt(&val);
+        r = toku_db_get(persistent_environment, txn, &key, &val, 0);
+        assert(r == 0);
+        PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_LAST_LSN_OF_V13) = toku_dtoh64(*(uint32_t*)val.data);
 
-	toku_fill_dbt(&key, upgrade_v19_time_key, strlen(upgrade_v19_time_key));
-	toku_init_dbt(&val);
-	r = toku_db_get(persistent_environment, txn, &key, &val, 0);
-	assert(r == 0);
-	PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_V14_TIME) = toku_dtoh64((*(time_t*)val.data));
+        toku_fill_dbt(&key, upgrade_v19_time_key, strlen(upgrade_v19_time_key));
+        toku_init_dbt(&val);
+        r = toku_db_get(persistent_environment, txn, &key, &val, 0);
+        assert(r == 0);
+        PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_V14_TIME) = toku_dtoh64((*(time_t*)val.data));
 
-	toku_fill_dbt(&key, upgrade_v19_footprint_key, strlen(upgrade_v19_footprint_key));
-	toku_init_dbt(&val);
-	r = toku_db_get(persistent_environment, txn, &key, &val, 0);
-	assert(r == 0);
-	PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_V14_FOOTPRINT) = toku_dtoh64((*(uint64_t*)val.data));
+        toku_fill_dbt(&key, upgrade_v19_footprint_key, strlen(upgrade_v19_footprint_key));
+        toku_init_dbt(&val);
+        r = toku_db_get(persistent_environment, txn, &key, &val, 0);
+        assert(r == 0);
+        PERSISTENT_UPGRADE_STATUS_VALUE(PERSISTENT_UPGRADE_V14_FOOTPRINT) = toku_dtoh64((*(uint64_t*)val.data));
     }
 
 }
@@ -640,79 +640,79 @@ validate_env(DB_ENV * env, BOOL * valid_newenv, BOOL need_rollback_cachefile) {
     int stat_errno = errno;
     toku_free(path);
     if (r == 0) {
-	expect_newenv = FALSE;  // persistent info exists
+        expect_newenv = FALSE;  // persistent info exists
     }
     else if (stat_errno == ENOENT) {
-	expect_newenv = TRUE;
-	r = 0;
+        expect_newenv = TRUE;
+        r = 0;
     }
     else {
-	r = toku_ydb_do_error(env, errno, "Unable to access persistent environment\n");
-	assert(r);
+        r = toku_ydb_do_error(env, errno, "Unable to access persistent environment\n");
+        assert(r);
     }
 
     // Test for existence of rollback cachefile if it is expected to exist
     if (r == 0 && need_rollback_cachefile) {
-	path = toku_construct_full_name(2, env->i->dir, ROLLBACK_CACHEFILE_NAME);
-	assert(path);
-	r = toku_stat(path, &buf);
-	stat_errno = errno;
-	toku_free(path);
-	if (r == 0) {  
-	    if (expect_newenv)  // rollback cachefile exists, but persistent env is missing
-		r = toku_ydb_do_error(env, ENOENT, "Persistent environment is missing\n");
-	}
-	else if (stat_errno == ENOENT) {
-	    if (!expect_newenv)  // rollback cachefile is missing but persistent env exists
-		r = toku_ydb_do_error(env, ENOENT, "rollback cachefile directory is missing\n");
-	    else 
-		r = 0;           // both rollback cachefile and persistent env are missing
-	}
-	else {
-	    r = toku_ydb_do_error(env, stat_errno, "Unable to access rollback cachefile\n");
-	    assert(r);
-	}
+        path = toku_construct_full_name(2, env->i->dir, ROLLBACK_CACHEFILE_NAME);
+        assert(path);
+        r = toku_stat(path, &buf);
+        stat_errno = errno;
+        toku_free(path);
+        if (r == 0) {  
+            if (expect_newenv)  // rollback cachefile exists, but persistent env is missing
+                r = toku_ydb_do_error(env, ENOENT, "Persistent environment is missing\n");
+        }
+        else if (stat_errno == ENOENT) {
+            if (!expect_newenv)  // rollback cachefile is missing but persistent env exists
+                r = toku_ydb_do_error(env, ENOENT, "rollback cachefile directory is missing\n");
+            else 
+                r = 0;           // both rollback cachefile and persistent env are missing
+        }
+        else {
+            r = toku_ydb_do_error(env, stat_errno, "Unable to access rollback cachefile\n");
+            assert(r);
+        }
     }
 
     // Test for fileops directory
     if (r == 0) {
-	path = toku_construct_full_name(2, env->i->dir, fileopsdirectory);
-	assert(path);
-	r = toku_stat(path, &buf);
-	stat_errno = errno;
-	toku_free(path);
-	if (r == 0) {  
-	    if (expect_newenv)  // fileops directory exists, but persistent env is missing
-		r = toku_ydb_do_error(env, ENOENT, "Persistent environment is missing\n");
-	}
-	else if (stat_errno == ENOENT) {
-	    if (!expect_newenv)  // fileops directory is missing but persistent env exists
-		r = toku_ydb_do_error(env, ENOENT, "Fileops directory is missing\n");
-	    else 
-		r = 0;           // both fileops directory and persistent env are missing
-	}
-	else {
-	    r = toku_ydb_do_error(env, stat_errno, "Unable to access fileops directory\n");
-	    assert(r);
-	}
+        path = toku_construct_full_name(2, env->i->dir, fileopsdirectory);
+        assert(path);
+        r = toku_stat(path, &buf);
+        stat_errno = errno;
+        toku_free(path);
+        if (r == 0) {  
+            if (expect_newenv)  // fileops directory exists, but persistent env is missing
+                r = toku_ydb_do_error(env, ENOENT, "Persistent environment is missing\n");
+        }
+        else if (stat_errno == ENOENT) {
+            if (!expect_newenv)  // fileops directory is missing but persistent env exists
+                r = toku_ydb_do_error(env, ENOENT, "Fileops directory is missing\n");
+            else 
+                r = 0;           // both fileops directory and persistent env are missing
+        }
+        else {
+            r = toku_ydb_do_error(env, stat_errno, "Unable to access fileops directory\n");
+            assert(r);
+        }
     }
 
     // Test for recovery log
     if ((r == 0) && (env->i->open_flags & DB_INIT_LOG)) {
-	// if using transactions, test for existence of log
-	r = ydb_recover_log_exists(env);  // return 0 or ENOENT
-	if (expect_newenv && (r != ENOENT))
-	    r = toku_ydb_do_error(env, ENOENT, "Persistent environment information is missing (but log exists)\n");
-	else if (!expect_newenv && r == ENOENT)
-	    r = toku_ydb_do_error(env, ENOENT, "Recovery log is missing (persistent environment information is present)\n");
-	else
-	    r = 0;
+        // if using transactions, test for existence of log
+        r = ydb_recover_log_exists(env);  // return 0 or ENOENT
+        if (expect_newenv && (r != ENOENT))
+            r = toku_ydb_do_error(env, ENOENT, "Persistent environment information is missing (but log exists)\n");
+        else if (!expect_newenv && r == ENOENT)
+            r = toku_ydb_do_error(env, ENOENT, "Recovery log is missing (persistent environment information is present)\n");
+        else
+            r = 0;
     }
 
     if (r == 0)
-	*valid_newenv = expect_newenv;
+        *valid_newenv = expect_newenv;
     else 
-	*valid_newenv = FALSE;
+        *valid_newenv = FALSE;
     return r;
 }
 
@@ -760,7 +760,7 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
     u_int32_t unused_flags=flags;
 
     if (env_opened(env)) {
-	r = toku_ydb_do_error(env, EINVAL, "The environment is already open\n");
+        r = toku_ydb_do_error(env, EINVAL, "The environment is already open\n");
         goto cleanup;
     }
 
@@ -775,17 +775,17 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
     // DB_CREATE means create if env does not exist, and Tokudb requires it because
     // Tokudb requries DB_PRIVATE.
     if ((flags & DB_PRIVATE) && !(flags & DB_CREATE)) {
-	r = toku_ydb_do_error(env, ENOENT, "DB_PRIVATE requires DB_CREATE (seems gratuitous to us, but that's BDB's behavior\n");
+        r = toku_ydb_do_error(env, ENOENT, "DB_PRIVATE requires DB_CREATE (seems gratuitous to us, but that's BDB's behavior\n");
         goto cleanup;
     }
 
     if (!(flags & DB_PRIVATE)) {
-	r = toku_ydb_do_error(env, ENOENT, "TokuDB requires DB_PRIVATE\n");
+        r = toku_ydb_do_error(env, ENOENT, "TokuDB requires DB_PRIVATE\n");
         goto cleanup;
     }
 
     if ((flags & DB_INIT_LOG) && !(flags & DB_INIT_TXN)) {
-	r = toku_ydb_do_error(env, EINVAL, "TokuDB requires transactions for logging\n");
+        r = toku_ydb_do_error(env, EINVAL, "TokuDB requires transactions for logging\n");
         goto cleanup;
     }
 
@@ -793,23 +793,23 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
 
     // Verify that the home exists.
     {
-	BOOL made_new_home = FALSE;
+        BOOL made_new_home = FALSE;
         char* new_home = NULL;
-    	toku_struct_stat buf;
+            toku_struct_stat buf;
         if (strlen(home) > 1 && home[strlen(home)-1] == '\\') {
             new_home = toku_malloc(strlen(home));
             memcpy(new_home, home, strlen(home));
             new_home[strlen(home) - 1] = 0;
             made_new_home = TRUE;
         }
-    	r = toku_stat(made_new_home? new_home : home, &buf);
+            r = toku_stat(made_new_home? new_home : home, &buf);
         if (made_new_home) {
             toku_free(new_home);
         }
-    	if (r!=0) {
-    	    r = toku_ydb_do_error(env, errno, "Error from toku_stat(\"%s\",...)\n", home);
+            if (r!=0) {
+                r = toku_ydb_do_error(env, errno, "Error from toku_stat(\"%s\",...)\n", home);
             goto cleanup;
-    	}
+            }
     }
     unused_flags &= ~DB_PRIVATE;
 
@@ -817,7 +817,7 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
         toku_free(env->i->dir);
     env->i->dir = toku_strdup(home);
     if (env->i->dir == 0) {
-	r = toku_ydb_do_error(env, ENOMEM, "Out of memory\n");
+        r = toku_ydb_do_error(env, ENOMEM, "Out of memory\n");
         goto cleanup;
     }
     if (0) {
@@ -856,14 +856,14 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
     if (r!=0) goto cleanup;
 
     if (upgrade_in_progress) {
-	// Delete old rollback file.  There was a clean shutdown, so it has nothing useful,
-	// and there is no value in upgrading it.  It is simpler to just create a new one.
-	char* rollback_filename = toku_construct_full_name(2, env->i->dir, ROLLBACK_CACHEFILE_NAME);
-	assert(rollback_filename);
-	r = unlink(rollback_filename);
-	toku_free(rollback_filename);
-	assert(r==0 || errno==ENOENT);	
-	need_rollback_cachefile = FALSE;  // we're not expecting it to exist now
+        // Delete old rollback file.  There was a clean shutdown, so it has nothing useful,
+        // and there is no value in upgrading it.  It is simpler to just create a new one.
+        char* rollback_filename = toku_construct_full_name(2, env->i->dir, ROLLBACK_CACHEFILE_NAME);
+        assert(rollback_filename);
+        r = unlink(rollback_filename);
+        toku_free(rollback_filename);
+        assert(r==0 || errno==ENOENT);        
+        need_rollback_cachefile = FALSE;  // we're not expecting it to exist now
     }
     
     r = validate_env(env, &newenv, need_rollback_cachefile);  // make sure that environment is either new or complete
@@ -890,20 +890,20 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
     toku_loader_cleanup_temp_files(env);
 
     if (flags & (DB_INIT_TXN | DB_INIT_LOG)) {
-	assert(env->i->logger);
+        assert(env->i->logger);
         toku_logger_write_log_files(env->i->logger, (BOOL)((flags & DB_INIT_LOG) != 0));
-	if (!toku_logger_is_open(env->i->logger)) {
-	    r = toku_logger_open(env->i->real_log_dir, env->i->logger);
-	    if (r!=0) {
-		toku_ydb_do_error(env, r, "Could not open logger\n");
-	    died2:
-		toku_logger_close(&env->i->logger);
-		goto died1;
-	    }
-	}
+        if (!toku_logger_is_open(env->i->logger)) {
+            r = toku_logger_open(env->i->real_log_dir, env->i->logger);
+            if (r!=0) {
+                toku_ydb_do_error(env, r, "Could not open logger\n");
+            died2:
+                toku_logger_close(&env->i->logger);
+                goto died1;
+            }
+        }
     } else {
-	r = toku_logger_close(&env->i->logger); // if no logging system, then kill the logger
-	assert_zero(r);
+        r = toku_logger_close(&env->i->logger); // if no logging system, then kill the logger
+        assert_zero(r);
     }
 
     r = toku_ltm_open(env->i->ltm);
@@ -916,13 +916,13 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
 
 // This is probably correct, but it will be pain...
 //    if ((flags & DB_THREAD)==0) {
-//	r = toku_ydb_do_error(env, EINVAL, "TokuDB requires DB_THREAD");
-//	goto cleanup;
+//        r = toku_ydb_do_error(env, EINVAL, "TokuDB requires DB_THREAD");
+//        goto cleanup;
 //    }
     unused_flags &= ~DB_THREAD;
 
     if (unused_flags!=0) {
-	r = toku_ydb_do_error(env, EINVAL, "Extra flags not understood by tokudb: %u\n", unused_flags);
+        r = toku_ydb_do_error(env, EINVAL, "Extra flags not understood by tokudb: %u\n", unused_flags);
         goto cleanup;
     }
 
@@ -936,15 +936,15 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
 
     int using_txns = env->i->open_flags & DB_INIT_TXN;
     if (env->i->logger) {
-	// if this is a newborn env or if this is an upgrade, then create a brand new rollback file
-	assert (using_txns);
-	toku_logger_set_cachetable(env->i->logger, env->i->cachetable);
-	toku_logger_set_remove_finalize_callback(env->i->logger, finalize_file_removal, env->i->ltm);
-	if (!toku_logger_rollback_is_open(env->i->logger)) {
-	    BOOL create_new_rollback_file = newenv | upgrade_in_progress;
-	    r = toku_logger_open_rollback(env->i->logger, env->i->cachetable, create_new_rollback_file);
-	    assert(r==0);
-	}
+        // if this is a newborn env or if this is an upgrade, then create a brand new rollback file
+        assert (using_txns);
+        toku_logger_set_cachetable(env->i->logger, env->i->cachetable);
+        toku_logger_set_remove_finalize_callback(env->i->logger, finalize_file_removal, env->i->ltm);
+        if (!toku_logger_rollback_is_open(env->i->logger)) {
+            BOOL create_new_rollback_file = newenv | upgrade_in_progress;
+            r = toku_logger_open_rollback(env->i->logger, env->i->cachetable, create_new_rollback_file);
+            assert(r==0);
+        }
     }
 
     DB_TXN *txn=NULL;
@@ -958,35 +958,35 @@ toku_env_open(DB_ENV * env, const char *home, u_int32_t flags, int mode) {
         assert_zero(r);
         r = db_use_builtin_key_cmp(env->i->persistent_environment);
         assert_zero(r);
-	r = db_open_iname(env->i->persistent_environment, txn, environmentdictionary, DB_CREATE, mode);
-	assert_zero(r);
-	if (newenv) {
-	    // create new persistent_environment
-	    DBT key, val;
-	    uint32_t persistent_original_env_version = FT_LAYOUT_VERSION;
-	    const uint32_t environment_version = toku_htod32(persistent_original_env_version);
-
-	    toku_fill_dbt(&key, orig_env_ver_key, strlen(orig_env_ver_key));
-	    toku_fill_dbt(&val, &environment_version, sizeof(environment_version));
-	    r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
-	    assert_zero(r);
-
-	    toku_fill_dbt(&key, curr_env_ver_key, strlen(curr_env_ver_key));
-	    toku_fill_dbt(&val, &environment_version, sizeof(environment_version));
-	    r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
-	    assert_zero(r);
-
-	    time_t creation_time_d = toku_htod64(time(NULL));
-	    toku_fill_dbt(&key, creation_time_key, strlen(creation_time_key));
-	    toku_fill_dbt(&val, &creation_time_d, sizeof(creation_time_d));
-	    r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
-	    assert_zero(r);
-	}
-	else {
-	    r = maybe_upgrade_persistent_environment_dictionary(env, txn, last_lsn_of_clean_shutdown_read_from_log);
-	    assert_zero(r);
-	}
-	capture_persistent_env_contents(env, txn);
+        r = db_open_iname(env->i->persistent_environment, txn, environmentdictionary, DB_CREATE, mode);
+        assert_zero(r);
+        if (newenv) {
+            // create new persistent_environment
+            DBT key, val;
+            uint32_t persistent_original_env_version = FT_LAYOUT_VERSION;
+            const uint32_t environment_version = toku_htod32(persistent_original_env_version);
+
+            toku_fill_dbt(&key, orig_env_ver_key, strlen(orig_env_ver_key));
+            toku_fill_dbt(&val, &environment_version, sizeof(environment_version));
+            r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
+            assert_zero(r);
+
+            toku_fill_dbt(&key, curr_env_ver_key, strlen(curr_env_ver_key));
+            toku_fill_dbt(&val, &environment_version, sizeof(environment_version));
+            r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
+            assert_zero(r);
+
+            time_t creation_time_d = toku_htod64(time(NULL));
+            toku_fill_dbt(&key, creation_time_key, strlen(creation_time_key));
+            toku_fill_dbt(&val, &creation_time_d, sizeof(creation_time_d));
+            r = toku_db_put(env->i->persistent_environment, txn, &key, &val, 0, TRUE);
+            assert_zero(r);
+        }
+        else {
+            r = maybe_upgrade_persistent_environment_dictionary(env, txn, last_lsn_of_clean_shutdown_read_from_log);
+            assert_zero(r);
+        }
+        capture_persistent_env_contents(env, txn);
     }
     {
         r = toku_db_create(&env->i->directory, env, 0);
@@ -1013,11 +1013,11 @@ cleanup:
         }
     }
     if (r == 0) {
-	errno = 0; // tabula rasa.   If there's a crash after env was successfully opened, no misleading errno will have been left around by this code.
-	most_recent_env = env;
+        errno = 0; // tabula rasa.   If there's a crash after env was successfully opened, no misleading errno will have been left around by this code.
+        most_recent_env = env;
         uint64_t num_rows;
         env_get_engine_status_num_rows(env, &num_rows);
-	toku_assert_set_fpointers(toku_maybe_get_engine_status_text, toku_maybe_set_env_panic, num_rows);
+        toku_assert_set_fpointers(toku_maybe_get_engine_status_text, toku_maybe_set_env_panic, num_rows);
     }
     return r;
 }
@@ -1034,7 +1034,7 @@ toku_env_close(DB_ENV * env, u_int32_t flags) {
 
     if (toku_env_is_panicked(env)) goto panic_and_quit_early;
     if (env->i->open_txns != 0) {
-	err_msg = "Cannot close environment due to open transactions\n";
+        err_msg = "Cannot close environment due to open transactions\n";
         r = toku_ydb_do_error(env, EINVAL, "%s", err_msg);
         goto panic_and_quit_early;
     }
@@ -1042,7 +1042,7 @@ toku_env_close(DB_ENV * env, u_int32_t flags) {
         uint32_t size = toku_omt_size(env->i->open_dbs);
         assert(size == env->i->num_open_dbs);
         if (env->i->num_open_dbs > 0) {
-	    err_msg = "Cannot close environment due to open DBs\n";
+            err_msg = "Cannot close environment due to open DBs\n";
             r = toku_ydb_do_error(env, EINVAL, "%s", err_msg);
             goto panic_and_quit_early;
         }
@@ -1051,7 +1051,7 @@ toku_env_close(DB_ENV * env, u_int32_t flags) {
         if (env->i->persistent_environment) {
             r = toku_db_close(env->i->persistent_environment);
             if (r) {
-		err_msg = "Cannot close persistent environment dictionary (DB->close error)\n";
+                err_msg = "Cannot close persistent environment dictionary (DB->close error)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
@@ -1059,65 +1059,65 @@ toku_env_close(DB_ENV * env, u_int32_t flags) {
         if (env->i->directory) {
             r = toku_db_close(env->i->directory);
             if (r) {
-		err_msg = "Cannot close Directory dictionary (DB->close error)\n";
+                err_msg = "Cannot close Directory dictionary (DB->close error)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
         }
     }
     if (env->i->cachetable) {
-	toku_ydb_unlock();  // ydb lock must not be held when shutting down minicron
-	toku_cachetable_minicron_shutdown(env->i->cachetable);
+        toku_ydb_unlock();  // ydb lock must not be held when shutting down minicron
+        toku_cachetable_minicron_shutdown(env->i->cachetable);
         if (env->i->logger) {
             r = toku_checkpoint(env->i->cachetable, env->i->logger, NULL, NULL, NULL, NULL, SHUTDOWN_CHECKPOINT);
             if (r) {
-		err_msg = "Cannot close environment (error during checkpoint)\n";
+                err_msg = "Cannot close environment (error during checkpoint)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
             r = toku_logger_close_rollback(env->i->logger, FALSE);
             if (r) {
-		err_msg = "Cannot close environment (error during closing rollback cachefile)\n";
+                err_msg = "Cannot close environment (error during closing rollback cachefile)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
             //Do a second checkpoint now that the rollback cachefile is closed.
             r = toku_checkpoint(env->i->cachetable, env->i->logger, NULL, NULL, NULL, NULL, SHUTDOWN_CHECKPOINT);
             if (r) {
-		err_msg = "Cannot close environment (error during checkpoint)\n";
+                err_msg = "Cannot close environment (error during checkpoint)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
             r = toku_logger_shutdown(env->i->logger); 
             if (r) {
-		err_msg = "Cannot close environment (error during logger shutdown)\n";
+                err_msg = "Cannot close environment (error during logger shutdown)\n";
                 toku_ydb_do_error(env, r, "%s", err_msg);
                 goto panic_and_quit_early;
             }
         }
-	toku_ydb_lock();
+        toku_ydb_lock();
         r=toku_cachetable_close(&env->i->cachetable);
-	if (r) {
-	    err_msg = "Cannot close environment (cachetable close error)\n";
-	    toku_ydb_do_error(env, r, "%s", err_msg);
+        if (r) {
+            err_msg = "Cannot close environment (cachetable close error)\n";
+            toku_ydb_do_error(env, r, "%s", err_msg);
             goto panic_and_quit_early;
-	}
+        }
     }
     if (env->i->logger) {
         r=toku_logger_close(&env->i->logger);
-	if (r) {
-	    err_msg = "Cannot close environment (logger close error)\n";
+        if (r) {
+            err_msg = "Cannot close environment (logger close error)\n";
             env->i->logger = NULL;
-	    toku_ydb_do_error(env, r, "%s", err_msg);
+            toku_ydb_do_error(env, r, "%s", err_msg);
             goto panic_and_quit_early;
-	}
+        }
     }
     // Even if nothing else went wrong, but we were panicked, then raise an error.
     // But if something else went wrong then raise that error (above)
     if (toku_env_is_panicked(env))
         goto panic_and_quit_early;
     else
-	assert(env->i->panic_string==0);
+        assert(env->i->panic_string==0);
 
     env_fs_destroy(env);
     if (env->i->ltm) {
@@ -1131,15 +1131,15 @@ toku_env_close(DB_ENV * env, u_int32_t flags) {
     if (env->i->tmp_dir)
         toku_free(env->i->tmp_dir);
     if (env->i->real_data_dir)
-	toku_free(env->i->real_data_dir);
+        toku_free(env->i->real_data_dir);
     if (env->i->real_log_dir)
-	toku_free(env->i->real_log_dir);
+        toku_free(env->i->real_log_dir);
     if (env->i->real_tmp_dir)
-	toku_free(env->i->real_tmp_dir);
+        toku_free(env->i->real_tmp_dir);
     if (env->i->open_dbs)
         toku_omt_destroy(&env->i->open_dbs);
     if (env->i->dir)
-	toku_free(env->i->dir);
+        toku_free(env->i->dir);
     //Immediately before freeing internal environment unlock the directories
     unlock_single_process(env);
     toku_free(env->i);
@@ -1159,7 +1159,7 @@ panic_and_quit_early:
         r = toku_ydb_do_error(env, toku_env_is_panicked(env), "Cannot close environment due to previous error: %s\n", panic_string);
     }
     else {
-	env_panic(env, r, err_msg);
+        env_panic(env, r, err_msg);
     }
     return r;
 }
@@ -1233,10 +1233,10 @@ toku_env_set_data_dir(DB_ENV * env, const char *dir) {
     int r;
     
     if (env_opened(env) || !dir) {
-	r = toku_ydb_do_error(env, EINVAL, "You cannot set the data dir after opening the env\n");
+        r = toku_ydb_do_error(env, EINVAL, "You cannot set the data dir after opening the env\n");
     }
     else if (env->i->data_dir)
-	r = toku_ydb_do_error(env, EINVAL, "You cannot set the data dir more than once.\n");
+        r = toku_ydb_do_error(env, EINVAL, "You cannot set the data dir more than once.\n");
     else {
         env->i->data_dir = toku_strdup(dir);
         if (env->i->data_dir==NULL) {
@@ -1273,7 +1273,7 @@ toku_env_set_flags(DB_ENV * env, u_int32_t flags, int onoff) {
         flags  &= ~DB_AUTO_COMMIT;
     }
     if (flags != 0 && onoff) {
-	return toku_ydb_do_error(env, EINVAL, "TokuDB does not (yet) support any nonzero ENV flags other than DB_AUTO_COMMIT\n");
+        return toku_ydb_do_error(env, EINVAL, "TokuDB does not (yet) support any nonzero ENV flags other than DB_AUTO_COMMIT\n");
     }
     if   (onoff) env->i->open_flags |=  change;
     else         env->i->open_flags &= ~change;
@@ -1290,15 +1290,15 @@ static int
 toku_env_set_lg_dir(DB_ENV * env, const char *dir) {
     HANDLE_PANICKED_ENV(env);
     if (env_opened(env)) {
-	return toku_ydb_do_error(env, EINVAL, "Cannot set log dir after opening the env\n");
+        return toku_ydb_do_error(env, EINVAL, "Cannot set log dir after opening the env\n");
     }
 
     if (env->i->lg_dir) toku_free(env->i->lg_dir);
     if (dir) {
         env->i->lg_dir = toku_strdup(dir);
         if (!env->i->lg_dir) {
-	    return toku_ydb_do_error(env, ENOMEM, "Out of memory\n");
-	}
+            return toku_ydb_do_error(env, ENOMEM, "Out of memory\n");
+        }
     }
     else env->i->lg_dir = NULL;
     return 0;
@@ -1419,10 +1419,10 @@ static int
 toku_env_set_tmp_dir(DB_ENV * env, const char *tmp_dir) {
     HANDLE_PANICKED_ENV(env);
     if (env_opened(env)) {
-	return toku_ydb_do_error(env, EINVAL, "Cannot set the tmp dir after opening an env\n");
+        return toku_ydb_do_error(env, EINVAL, "Cannot set the tmp dir after opening an env\n");
     }
     if (!tmp_dir) {
-	return toku_ydb_do_error(env, EINVAL, "Tmp dir bust be non-null\n");
+        return toku_ydb_do_error(env, EINVAL, "Tmp dir bust be non-null\n");
     }
     if (env->i->tmp_dir)
         toku_free(env->i->tmp_dir);
@@ -1439,12 +1439,12 @@ toku_env_set_verbose(DB_ENV * env, u_int32_t UU(which), int UU(onoff)) {
 static int 
 toku_env_txn_checkpoint(DB_ENV * env, u_int32_t kbyte __attribute__((__unused__)), u_int32_t min __attribute__((__unused__)), u_int32_t flags __attribute__((__unused__))) {
     int r = toku_checkpoint(env->i->cachetable, env->i->logger,
-			    checkpoint_callback_f,  checkpoint_callback_extra,
-			    checkpoint_callback2_f, checkpoint_callback2_extra,
-			    CLIENT_CHECKPOINT);
+                            checkpoint_callback_f,  checkpoint_callback_extra,
+                            checkpoint_callback2_f, checkpoint_callback2_extra,
+                            CLIENT_CHECKPOINT);
     if (r) {
-	// Panicking the whole environment may be overkill, but I'm not sure what else to do.
-	env_panic(env, r, "checkpoint error\n");
+        // Panicking the whole environment may be overkill, but I'm not sure what else to do.
+        env_panic(env, r, "checkpoint error\n");
         toku_ydb_do_error(env, r, "Checkpoint\n");
     }
     return r;
@@ -1909,9 +1909,9 @@ typedef struct {
 static FS_STATUS_S fsstat;
 
 #define FS_STATUS_INIT(k,t,l) {           \
-	fsstat.status[k].keyname = #k; \
-	fsstat.status[k].type    = t;  \
-	fsstat.status[k].legend  = "filesystem: " l; \
+        fsstat.status[k].keyname = #k; \
+        fsstat.status[k].type    = t;  \
+        fsstat.status[k].legend  = "filesystem: " l; \
     }
 
 static void
@@ -1978,9 +1978,9 @@ typedef struct {
 static MEMORY_STATUS_S memory_status;
 
 #define STATUS_INIT(k,t,l) { \
-	memory_status.status[k].keyname = #k; \
-	memory_status.status[k].type    = t;  \
-	memory_status.status[k].legend  = "memory: " l; \
+        memory_status.status[k].keyname = #k; \
+        memory_status.status[k].type    = t;  \
+        memory_status.status[k].legend  = "memory: " l; \
     }
 
 static void
@@ -2007,7 +2007,7 @@ memory_status_init(void) {
 static void
 memory_get_status(void) {
     if (!memory_status.initialized)
-	memory_status_init();
+        memory_status_init();
     LOCAL_MEMORY_STATUS_S local_memstat;
     toku_memory_get_status(&local_memstat);
     MEMORY_STATUS_VALUE(MEMORY_MALLOC_COUNT) = local_memstat.malloc_count;
@@ -2066,79 +2066,79 @@ env_get_engine_status (DB_ENV * env, TOKU_ENGINE_STATUS_ROW engstat, uint64_t ma
     int r;
 
     if (env_panic_string_buf) {
-	if (env && env->i && env->i->is_panicked && env->i->panic_string) {
-	    strncpy(env_panic_string_buf, env->i->panic_string, env_panic_string_length);
-	    env_panic_string_buf[env_panic_string_length - 1] = '\0';  // just in case
-	}
-	else 
-	    *env_panic_string_buf = '\0';
+        if (env && env->i && env->i->is_panicked && env->i->panic_string) {
+            strncpy(env_panic_string_buf, env->i->panic_string, env_panic_string_length);
+            env_panic_string_buf[env_panic_string_length - 1] = '\0';  // just in case
+        }
+        else 
+            *env_panic_string_buf = '\0';
     }
 
     if ( !(env)     || 
-	 !(env->i)  || 
-	 !(env_opened(env)) )
-	r = EINVAL;
+         !(env->i)  || 
+         !(env_opened(env)) )
+        r = EINVAL;
     else {
-	r = 0;
-	uint64_t row = 0;  // which row to fill next
+        r = 0;
+        uint64_t row = 0;  // which row to fill next
         *env_panicp = env->i->is_panicked;
 
-	{
-	    YDB_LAYER_STATUS_S ydb_stat;
-	    ydb_layer_get_status(&ydb_stat);
-	    for (int i = 0; i < YDB_LAYER_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = ydb_stat.status[i];
-	    }
-	}
+        {
+            YDB_LAYER_STATUS_S ydb_stat;
+            ydb_layer_get_status(&ydb_stat);
+            for (int i = 0; i < YDB_LAYER_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = ydb_stat.status[i];
+            }
+        }
         {
             YDB_C_LAYER_STATUS_S ydb_c_stat;
             ydb_c_layer_get_status(&ydb_c_stat);
             for (int i = 0; i < YDB_C_LAYER_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = ydb_c_stat.status[i];
             }
-	}
+        }
         {
             YDB_WRITE_LAYER_STATUS_S ydb_write_stat;
             ydb_write_layer_get_status(&ydb_write_stat);
             for (int i = 0; i < YDB_WRITE_LAYER_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = ydb_write_stat.status[i];
             }
-	}
-	{
-	    YDB_LOCK_STATUS_S ydb_lock_status;
-	    toku_ydb_lock_get_status(&ydb_lock_status);
-	    for (int i = 0; i < YDB_LOCK_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = ydb_lock_status.status[i];
-	    }
-	}
+        }
         {
-	    LE_STATUS_S lestat;                    // Rice's vampire
-	    toku_le_get_status(&lestat);
-	    for (int i = 0; i < LE_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = lestat.status[i];
-	    }
+            YDB_LOCK_STATUS_S ydb_lock_status;
+            toku_ydb_lock_get_status(&ydb_lock_status);
+            for (int i = 0; i < YDB_LOCK_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = ydb_lock_status.status[i];
+            }
         }
-	{
+        {
+            LE_STATUS_S lestat;                    // Rice's vampire
+            toku_le_get_status(&lestat);
+            for (int i = 0; i < LE_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = lestat.status[i];
+            }
+        }
+        {
             CHECKPOINT_STATUS_S cpstat;
             toku_checkpoint_get_status(env->i->cachetable, &cpstat);
-	    for (int i = 0; i < CP_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = cpstat.status[i];
-	    }
-	}
-	{
-	    CACHETABLE_STATUS_S ctstat;
-	    toku_cachetable_get_status(env->i->cachetable, &ctstat);
-	    for (int i = 0; i < CT_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = ctstat.status[i];
-	    }
-	}
-	{
-	    LTM_STATUS_S ltmstat;
-	    toku_ltm_get_status(env->i->ltm, &ltmstat);
-	    for (int i = 0; i < LTM_STATUS_NUM_ROWS && row < maxrows; i++) {
-		engstat[row++] = ltmstat.status[i];
-	    }
-	}
+            for (int i = 0; i < CP_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = cpstat.status[i];
+            }
+        }
+        {
+            CACHETABLE_STATUS_S ctstat;
+            toku_cachetable_get_status(env->i->cachetable, &ctstat);
+            for (int i = 0; i < CT_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = ctstat.status[i];
+            }
+        }
+        {
+            LTM_STATUS_S ltmstat;
+            toku_ltm_get_status(env->i->ltm, &ltmstat);
+            for (int i = 0; i < LTM_STATUS_NUM_ROWS && row < maxrows; i++) {
+                engstat[row++] = ltmstat.status[i];
+            }
+        }
         {
             FT_STATUS_S ftstat;
             toku_ft_get_status(&ftstat);
@@ -2190,34 +2190,34 @@ env_get_engine_status (DB_ENV * env, TOKU_ENGINE_STATUS_ROW engstat, uint64_t ma
             }
         }
 
-	{
+        {
             // memory_status is local to this file
-	    memory_get_status();
+            memory_get_status();
             for (int i = 0; i < MEMORY_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = memory_status.status[i];
             }
-	}
-	{
+        }
+        {
             // Note, fs_get_status() and the fsstat structure are local to this file because they
             // are used to concentrate file system information collected from various places.
             fs_get_status(env, redzone_state);
             for (int i = 0; i < FS_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = fsstat.status[i];
             }
-	}
+        }
 #if 0
         // enable when upgrade is supported
-	{
+        {
             for (int i = 0; i < PERSISTENT_UPGRADE_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = persistent_upgrade_status.status[i];
             }
             FT_UPGRADE_STATUS_S ft_upgradestat;
-	    toku_ft_upgrade_get_status(&ft_upgradestat);
+            toku_ft_upgrade_get_status(&ft_upgradestat);
             for (int i = 0; i < FT_UPGRADE_STATUS_NUM_ROWS && row < maxrows; i++) {
                 engstat[row++] = ft_upgradestat.status[i];
             }
 
-	}
+        }
 #endif
     }
     return r;
@@ -2244,15 +2244,15 @@ env_get_engine_status_text(DB_ENV * env, char * buff, int bufsiz) {
     
     if (r) {
         n += snprintf(buff + n, bufsiz - n, "Engine status not available: ");
-	if (!env) {
+        if (!env) {
         n += snprintf(buff + n, bufsiz - n, "no environment\n");
-	}
-	else if (!(env->i)) {
+        }
+        else if (!(env->i)) {
         n += snprintf(buff + n, bufsiz - n, "environment internal struct is null\n");
-	}
-	else if (!env_opened(env)) {
-	    n += snprintf(buff + n, bufsiz - n, "environment is not open\n");
-	}
+        }
+        else if (!env_opened(env)) {
+            n += snprintf(buff + n, bufsiz - n, "environment is not open\n");
+        }
     }
     else {
         if (panic) {
@@ -2296,9 +2296,9 @@ env_get_engine_status_text(DB_ENV * env, char * buff, int bufsiz) {
     }
         
     if (n > bufsiz) {
-	char * errmsg = "BUFFER TOO SMALL\n";
-	int len = strlen(errmsg) + 1;
-	(void) snprintf(buff + (bufsiz - 1) - len, len, "%s", errmsg);
+        char * errmsg = "BUFFER TOO SMALL\n";
+        int len = strlen(errmsg) + 1;
+        (void) snprintf(buff + (bufsiz - 1) - len, len, "%s", errmsg);
     }
 
     return r;
@@ -2310,11 +2310,11 @@ toku_maybe_get_engine_status_text (char * buff, int buffsize) {
     DB_ENV * env = most_recent_env;
     int r;
     if (engine_status_enable) {
-	r = env_get_engine_status_text(env, buff, buffsize);
+        r = env_get_engine_status_text(env, buff, buffsize);
     }
     else {
-	r = ENODATA;
-	snprintf(buff, buffsize, "Engine status not available: disabled by user.  This should only happen in test programs.\n");
+        r = ENODATA;
+        snprintf(buff, buffsize, "Engine status not available: disabled by user.  This should only happen in test programs.\n");
     }
     return r;
 }
@@ -2324,15 +2324,15 @@ toku_maybe_get_engine_status_text (char * buff, int buffsize) {
 static void 
 toku_maybe_set_env_panic(int code, char * msg) {
     if (code == 0) 
-	code = -1;
+        code = -1;
     if (msg == NULL)
-	msg = "Unknown cause from abort (failed assert)\n";
+        msg = "Unknown cause from abort (failed assert)\n";
     env_is_panicked = code;  // disable library destructor no matter what
     DB_ENV * env = most_recent_env;
     if (env && 
-	env->i &&
-	(env->i->is_panicked == 0)) {
-	env_panic(env, code, msg);
+        env->i &&
+        (env->i->is_panicked == 0)) {
+        env_panic(env, code, msg);
     }
 }
 
@@ -2525,7 +2525,7 @@ env_note_db_opened(DB_ENV *env, DB *db) {
     STATUS_VALUE(YDB_LAYER_NUM_OPEN_DBS) = env->i->num_open_dbs;
     STATUS_VALUE(YDB_LAYER_NUM_DB_OPEN)++;
     if (STATUS_VALUE(YDB_LAYER_NUM_OPEN_DBS) > STATUS_VALUE(YDB_LAYER_MAX_OPEN_DBS))
-	STATUS_VALUE(YDB_LAYER_MAX_OPEN_DBS) = STATUS_VALUE(YDB_LAYER_NUM_OPEN_DBS);
+        STATUS_VALUE(YDB_LAYER_MAX_OPEN_DBS) = STATUS_VALUE(YDB_LAYER_NUM_OPEN_DBS);
     r = toku_omt_find_zero(env->i->open_dbs, find_db_by_db, db, &dbv, &idx);
     assert(r==DB_NOTFOUND); //Must not already be there.
     r = toku_omt_insert_at(env->i->open_dbs, db, idx);
@@ -2665,8 +2665,8 @@ toku_env_dbremove(DB_ENV * env, DB_TXN *txn, const char *fname, const char *dbna
     DB_TXN *child = NULL;
     // begin child (unless transactionless)
     if (using_txns) {
-	r = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
-	assert_zero(r);
+        r = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
+        assert_zero(r);
     }
 
     // get iname
@@ -2675,14 +2675,14 @@ toku_env_dbremove(DB_ENV * env, DB_TXN *txn, const char *fname, const char *dbna
     if (r==DB_NOTFOUND)
         r = ENOENT;
     else if (r==0) {
-	// remove (dname,iname) from directory
-	r = toku_db_del(env->i->directory, child, &dname_dbt, DB_DELETE_ANY, TRUE);
-	if (r == 0) {
+        // remove (dname,iname) from directory
+        r = toku_db_del(env->i->directory, child, &dname_dbt, DB_DELETE_ANY, TRUE);
+        if (r == 0) {
             if (using_txns) {
                 // this writes an fdelete to the transaction's rollback log.
                 // it is removed if the child txn aborts after any error case below
                 r = toku_ft_remove_on_commit(db_txn_struct_i(child)->tokutxn, &iname_dbt);
-		assert_zero(r);
+                assert_zero(r);
                 //Now that we have a writelock on dname, verify that there are still no handles open. (to prevent race conditions)
                 if (r==0 && env_is_db_with_dname_open(env, dname))
                     r = toku_ydb_do_error(env, EINVAL, "Cannot remove dictionary with an open handle.\n");
@@ -2702,21 +2702,21 @@ toku_env_dbremove(DB_ENV * env, DB_TXN *txn, const char *fname, const char *dbna
             }
             else {
                 r = toku_ft_remove_now(env->i->cachetable, &iname_dbt);
-		assert_zero(r);
+                assert_zero(r);
             }
-	}
+        }
     }
 
     if (using_txns) {
-	// close txn
-	if (r == 0) {  // commit
-	    r = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
-	    invariant(r==0);  // TODO panic
-	}
-	else {         // abort
-	    int r2 = toku_txn_abort(child, NULL, NULL, false);
-	    invariant(r2==0);  // TODO panic
-	}
+        // close txn
+        if (r == 0) {  // commit
+            r = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
+            invariant(r==0);  // TODO panic
+        }
+        else {         // abort
+            int r2 = toku_txn_abort(child, NULL, NULL, false);
+            invariant(r2==0);  // TODO panic
+        }
     }
 
     if (iname) toku_free(iname);
@@ -2777,8 +2777,8 @@ toku_env_dbrename(DB_ENV *env, DB_TXN *txn, const char *fname, const char *dbnam
     DB_TXN *child = NULL;
     // begin child (unless transactionless)
     if (using_txns) {
-	r = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
-	assert_zero(r);
+        r = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
+        assert_zero(r);
     }
 
     char *iname;
@@ -2787,16 +2787,16 @@ toku_env_dbrename(DB_ENV *env, DB_TXN *txn, const char *fname, const char *dbnam
     if (r==DB_NOTFOUND)
         r = ENOENT;
     else if (r==0) {
-	// verify that newname does not already exist
+        // verify that newname does not already exist
         r = db_getf_set(env->i->directory, child, DB_SERIALIZABLE, &new_dname_dbt, ydb_getf_do_nothing, NULL);
-	if (r == 0) {
-	    r = EEXIST;
-	}
-	else if (r == DB_NOTFOUND) {
-	    // remove old (dname,iname) and insert (newname,iname) in directory
-	    r = toku_db_del(env->i->directory, child, &old_dname_dbt, DB_DELETE_ANY, TRUE);
-	    if (r == 0)
-		r = toku_db_put(env->i->directory, child, &new_dname_dbt, &iname_dbt, 0, TRUE);
+        if (r == 0) {
+            r = EEXIST;
+        }
+        else if (r == DB_NOTFOUND) {
+            // remove old (dname,iname) and insert (newname,iname) in directory
+            r = toku_db_del(env->i->directory, child, &old_dname_dbt, DB_DELETE_ANY, TRUE);
+            if (r == 0)
+                r = toku_db_put(env->i->directory, child, &new_dname_dbt, &iname_dbt, 0, TRUE);
             //Now that we have writelocks on both dnames, verify that there are still no handles open. (to prevent race conditions)
             if (r==0 && env_is_db_with_dname_open(env, dname))
                 r = toku_ydb_do_error(env, EINVAL, "Cannot rename dictionary with an open handle.\n");
@@ -2813,19 +2813,19 @@ toku_env_dbrename(DB_ENV *env, DB_TXN *txn, const char *fname, const char *dbnam
             if (r==0 && env_is_db_with_dname_open(env, newname)) {
                 r = toku_ydb_do_error(env, EINVAL, "Cannot rename dictionary; Dictionary with target name has an open handle.\n");
             }
-	}
+        }
     }
 
     if (using_txns) {
-	// close txn
-	if (r == 0) {  // commit
-	    r = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
-	    invariant(r==0);  // TODO panic
-	}
-	else {         // abort
-	    int r2 = toku_txn_abort(child, NULL, NULL, false);
-	    invariant(r2==0);  // TODO panic
-	}
+        // close txn
+        if (r == 0) {  // commit
+            r = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
+            invariant(r==0);  // TODO panic
+        }
+        else {         // abort
+            int r2 = toku_txn_abort(child, NULL, NULL, false);
+            invariant(r2==0);  // TODO panic
+        }
     }
 
     if (iname) toku_free(iname);

src/ydb_db.c

@@ -87,17 +87,17 @@ static char *
 create_iname(DB_ENV *env, u_int64_t id, char *hint, char *mark, int n) {
     int bytes;
     char inamebase[strlen(hint) +
-		   8 +  // hex file format version
-		   16 + // hex id (normally the txnid)
-		   8  + // hex value of n if non-neg
-		   sizeof("_B___.tokudb")]; // extra pieces
+                   8 +  // hex file format version
+                   16 + // hex id (normally the txnid)
+                   8  + // hex value of n if non-neg
+                   sizeof("_B___.tokudb")]; // extra pieces
     if (n < 0)
-	bytes = snprintf(inamebase, sizeof(inamebase),
+        bytes = snprintf(inamebase, sizeof(inamebase),
                          "%s_%"PRIx64"_%"PRIx32            ".tokudb",
                          hint, id, FT_LAYOUT_VERSION);
     else {
-	invariant(strlen(mark) == 1);
-	bytes = snprintf(inamebase, sizeof(inamebase),
+        invariant(strlen(mark) == 1);
+        bytes = snprintf(inamebase, sizeof(inamebase),
                          "%s_%"PRIx64"_%"PRIx32"_%s_%"PRIx32".tokudb",
                          hint, id, FT_LAYOUT_VERSION, mark, n);
     }
@@ -413,9 +413,9 @@ db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, u_int32_t flags,
 
     FT_HANDLE brt = db->i->ft_handle;
     r = toku_ft_handle_open(brt, iname_in_env,
-		      is_db_create, is_db_excl,
-		      db->dbenv->i->cachetable,
-		      txn ? db_txn_struct_i(txn)->tokutxn : NULL_TXN);
+                      is_db_create, is_db_excl,
+                      db->dbenv->i->cachetable,
+                      txn ? db_txn_struct_i(txn)->tokutxn : NULL_TXN);
     if (r != 0)
         goto error_cleanup;
 
@@ -429,7 +429,7 @@ db_open_iname(DB * db, DB_TXN * txn, const char *iname_in_env, u_int32_t flags,
     db->cmp_descriptor = &brt->ft->cmp_descriptor;
 
     if (need_locktree) {
-	db->i->dict_id = toku_ft_get_dictionary_id(db->i->ft_handle);
+        db->i->dict_id = toku_ft_get_dictionary_id(db->i->ft_handle);
         r = toku_ltm_get_lt(db->dbenv->i->ltm, &db->i->lt, db->i->dict_id, db->cmp_descriptor, toku_ft_get_bt_compare(db->i->ft_handle));
         if (r!=0) { goto error_cleanup; }
     }
@@ -471,9 +471,9 @@ int toku_db_pre_acquire_fileops_lock(DB *db, DB_TXN *txn) {
     //Left end of range == right end of range (point lock)
     int r = get_range_lock(db->dbenv->i->directory, txn, &key_in_directory, &key_in_directory, LOCK_REQUEST_WRITE);
     if (r == 0)
-	STATUS_VALUE(YDB_LAYER_DIRECTORY_WRITE_LOCKS)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_DIRECTORY_WRITE_LOCKS)++;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_DIRECTORY_WRITE_LOCKS_FAIL)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_DIRECTORY_WRITE_LOCKS_FAIL)++;  // accountability 
     return r;
 }
 
@@ -934,31 +934,31 @@ ydb_load_inames(DB_ENV * env, DB_TXN * txn, int N, DB * dbs[N], char * new_iname
     char * mark;
 
     if (mark_as_loader)
-	mark = "B";
+        mark = "B";
     else
-	mark = "P";
+        mark = "P";
 
     for (i=0; i<N; i++) {
-	new_inames_in_env[i] = NULL;
+        new_inames_in_env[i] = NULL;
     }
 
     // begin child (unless transactionless)
     if (using_txns) {
-	rval = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
-	assert(rval == 0);
-	xid = toku_txn_get_txnid(db_txn_struct_i(child)->tokutxn);
+        rval = toku_txn_begin(env, txn, &child, DB_TXN_NOSYNC, 1, true);
+        assert(rval == 0);
+        xid = toku_txn_get_txnid(db_txn_struct_i(child)->tokutxn);
     }
     for (i = 0; i < N; i++) {
-	char * dname = dbs[i]->i->dname;
-	toku_fill_dbt(&dname_dbt, dname, strlen(dname)+1);
-	// now create new iname
-	char hint[strlen(dname) + 1];
-	create_iname_hint(dname, hint);
-	char * new_iname = create_iname(env, xid, hint, mark, i);               // allocates memory for iname_in_env
-	new_inames_in_env[i] = new_iname;
+        char * dname = dbs[i]->i->dname;
+        toku_fill_dbt(&dname_dbt, dname, strlen(dname)+1);
+        // now create new iname
+        char hint[strlen(dname) + 1];
+        create_iname_hint(dname, hint);
+        char * new_iname = create_iname(env, xid, hint, mark, i);               // allocates memory for iname_in_env
+        new_inames_in_env[i] = new_iname;
         toku_fill_dbt(&iname_dbt, new_iname, strlen(new_iname) + 1);      // iname_in_env goes in directory
         rval = toku_db_put(env->i->directory, child, &dname_dbt, &iname_dbt, 0, TRUE);
-	if (rval) break;
+        if (rval) break;
     }
 
     // Generate load log entries.
@@ -977,23 +977,23 @@ ydb_load_inames(DB_ENV * env, DB_TXN * txn, int N, DB * dbs[N], char * new_iname
             if (rval) break;
         }
     }
-	
+        
     if (using_txns) {
-	// close txn
-	if (rval == 0) {  // all well so far, commit child
-	    rval = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
-	    assert(rval==0);
-	}
-	else {         // abort child
-	    int r2 = toku_txn_abort(child, NULL, NULL, false);
-	    assert(r2==0);
-	    for (i=0; i<N; i++) {
-		if (new_inames_in_env[i]) {
-		    toku_free(new_inames_in_env[i]);
-		    new_inames_in_env[i] = NULL;
-		}
-	    }
-	}
+        // close txn
+        if (rval == 0) {  // all well so far, commit child
+            rval = toku_txn_commit(child, DB_TXN_NOSYNC, NULL, NULL, false);
+            assert(rval==0);
+        }
+        else {         // abort child
+            int r2 = toku_txn_abort(child, NULL, NULL, false);
+            assert(r2==0);
+            for (i=0; i<N; i++) {
+                if (new_inames_in_env[i]) {
+                    toku_free(new_inames_in_env[i]);
+                    new_inames_in_env[i] = NULL;
+                }
+            }
+        }
     }
 
     return rval;

src/ydb_write.c

@@ -200,10 +200,10 @@ toku_db_put(DB *db, DB_TXN *txn, DBT *key, DBT *val, u_int32_t flags, BOOL holds
 
     if (r == 0) {
         // helgrind flags a race on this status update.  we increment it atomically to satisfy helgrind.
-	// STATUS_VALUE(YDB_LAYER_NUM_INSERTS)++;  // accountability 
+        // STATUS_VALUE(YDB_LAYER_NUM_INSERTS)++;  // accountability 
         (void) __sync_fetch_and_add(&STATUS_VALUE(YDB_LAYER_NUM_INSERTS), 1);
     } else {
-	// STATUS_VALUE(YDB_LAYER_NUM_INSERTS_FAIL)++;  // accountability 
+        // STATUS_VALUE(YDB_LAYER_NUM_INSERTS_FAIL)++;  // accountability 
         (void) __sync_fetch_and_add(&STATUS_VALUE(YDB_LAYER_NUM_INSERTS_FAIL), 1);
     }
 
@@ -239,9 +239,9 @@ toku_db_update(DB *db, DB_TXN *txn,
 
 cleanup:
     if (r == 0) 
-	STATUS_VALUE(YDB_LAYER_NUM_UPDATES)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_UPDATES)++;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_NUM_UPDATES_FAIL)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_UPDATES_FAIL)++;  // accountability 
     return r;
 }
 
@@ -294,9 +294,9 @@ toku_db_update_broadcast(DB *db, DB_TXN *txn,
 
 cleanup:
     if (r == 0) 
-	STATUS_VALUE(YDB_LAYER_NUM_UPDATES_BROADCAST)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_UPDATES_BROADCAST)++;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_NUM_UPDATES_BROADCAST_FAIL)++;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_UPDATES_BROADCAST_FAIL)++;  // accountability 
     return r;
 }
 
@@ -351,9 +351,9 @@ do_del_multiple(DB_TXN *txn, uint32_t num_dbs, DB *db_array[], DBT keys[], DB *s
 
         // if db is being indexed by an indexer, then insert a delete message into the db if the src key is to the left or equal to the 
         // indexers cursor.  we have to get the src_db from the indexer and find it in the db_array.
-	int do_delete = TRUE;
-	DB_INDEXER *indexer = toku_db_get_indexer(db);
-	if (indexer) { // if this db is the index under construction
+        int do_delete = TRUE;
+        DB_INDEXER *indexer = toku_db_get_indexer(db);
+        if (indexer) { // if this db is the index under construction
             DB *indexer_src_db = toku_indexer_get_src_db(indexer);
             invariant(indexer_src_db != NULL);
             const DBT *indexer_src_key;
@@ -366,7 +366,7 @@ do_del_multiple(DB_TXN *txn, uint32_t num_dbs, DB *db_array[], DBT keys[], DB *s
             }
             do_delete = !toku_indexer_is_key_right_of_le_cursor(indexer, indexer_src_db, indexer_src_key);
         }
-	if (r == 0 && do_delete) {
+        if (r == 0 && do_delete) {
             r = toku_ft_maybe_delete(db->i->ft_handle, &keys[which_db], ttxn, FALSE, ZERO_LSN, FALSE);
         }
     }
@@ -455,9 +455,9 @@ env_del_multiple(
 
 cleanup:
     if (r == 0)
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_DELETES) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_DELETES) += num_dbs;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_DELETES_FAIL) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_DELETES_FAIL) += num_dbs;  // accountability 
     return r;
 }
 
@@ -488,9 +488,9 @@ do_put_multiple(DB_TXN *txn, uint32_t num_dbs, DB *db_array[], DBT keys[], DBT v
 
         // if db is being indexed by an indexer, then put into that db if the src key is to the left or equal to the 
         // indexers cursor.  we have to get the src_db from the indexer and find it in the db_array.
-	int do_put = TRUE;
-	DB_INDEXER *indexer = toku_db_get_indexer(db);
-	if (indexer) { // if this db is the index under construction
+        int do_put = TRUE;
+        DB_INDEXER *indexer = toku_db_get_indexer(db);
+        if (indexer) { // if this db is the index under construction
             DB *indexer_src_db = toku_indexer_get_src_db(indexer);
             invariant(indexer_src_db != NULL);
             const DBT *indexer_src_key;
@@ -600,9 +600,9 @@ env_put_multiple_internal(
 
 cleanup:
     if (r == 0)
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_INSERTS) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_INSERTS) += num_dbs;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_INSERTS_FAIL) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_INSERTS_FAIL) += num_dbs;  // accountability 
     return r;
 }
 
@@ -755,9 +755,9 @@ env_update_multiple(DB_ENV *env, DB *src_db, DB_TXN *txn,
 
 cleanup:
     if (r == 0)
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_UPDATES) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_UPDATES) += num_dbs;  // accountability 
     else
-	STATUS_VALUE(YDB_LAYER_NUM_MULTI_UPDATES_FAIL) += num_dbs;  // accountability 
+        STATUS_VALUE(YDB_LAYER_NUM_MULTI_UPDATES_FAIL) += num_dbs;  // accountability 
     return r;
 }