compile on windows addresses #1253

git-svn-id: file:///svn/toku/tokudb.1032b@7847 c7de825b-a66e-492c-adef-691d508d4ae1

src/tests/big-nested-abort-abort.c

@@ -82,7 +82,7 @@ setup (void) {
     DB_TXN *txn;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     r=env->set_lk_max_locks(env, N); CKERR(r);
@@ -90,11 +90,11 @@ setup (void) {
     r=env->set_lk_max_objects(env, N); CKERR(r);
 #endif
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/big-nested-abort-commit.c

@@ -82,7 +82,7 @@ setup (void) {
     DB_TXN *txn;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     r=env->set_lk_max_locks(env, N); CKERR(r);
@@ -90,11 +90,11 @@ setup (void) {
     r=env->set_lk_max_objects(env, N); CKERR(r);
 #endif
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/big-nested-commit-abort.c

@@ -77,7 +77,7 @@ setup (void) {
     DB_TXN *txn;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     r=env->set_lk_max_locks(env, N); CKERR(r);
@@ -85,12 +85,12 @@ setup (void) {
     r=env->set_lk_max_objects(env, N); CKERR(r);
 #endif
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/big-nested-commit-commit.c

@@ -77,7 +77,7 @@ setup (void) {
     DB_TXN *txn;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     r=env->set_lk_max_locks(env, N); CKERR(r);
@@ -85,12 +85,12 @@ setup (void) {
     r=env->set_lk_max_objects(env, N); CKERR(r);
 #endif
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/bug627.c

@@ -9,17 +9,17 @@ do_627 (void) {
     DB_ENV *env;
     DB *db;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     DB_TXN *t1, *t2;
     DBT a,b;
     r=env->txn_begin(env, 0, &t1, 0); assert(r==0);
-    r=db->open(db, t1, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, t1, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db->put(db, t1, dbt_init(&a, "a", 2), dbt_init(&b, "b", 2), 0);
     r=t1->commit(t1, 0);    assert(r==0);
 

src/tests/cursor-more-than-a-leaf-provdel.c

@@ -13,7 +13,7 @@ static void
 setup (void) {
     system("rm -rf " ENVDIR);
     int r;
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
@@ -21,13 +21,13 @@ setup (void) {
     r=env->set_lk_max_objects(env, 2*num_insert); CKERR(r);
 #endif
     r=env->set_lk_max_locks(env, 2*num_insert); CKERR(r);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
     r=db->set_bt_compare(db, int_dbt_cmp); CKERR(r);
     r=db->set_dup_compare(db, int_dbt_cmp); CKERR(r);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/cursor-step-over-delete.c

@@ -11,15 +11,15 @@ static void
 test_setup (void) {
     system("rm -rf " ENVDIR);
     int r;
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/keyrange-dupsort-unflat.c

@@ -17,17 +17,17 @@ static void test (void) {
     u_int64_t ilimit=100;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
     // set the cachetable to size 1 so that things won't fit.
     r=env->set_cachesize(env, 0, 1, 1);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUP|DB_DUPSORT); assert(r==0);
     r=db->set_pagesize(db, 4096);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);

src/tests/keyrange-dupsort.c

@@ -17,17 +17,17 @@ static void test (void) {
     u_int64_t ilimit=10;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
     // set the cachetable to size 1 so that things won't fit.
     r=env->set_cachesize(env, 0, 1, 1);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUP|DB_DUPSORT); assert(r==0);
     r=db->set_pagesize(db, 4096);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);

src/tests/keyrange-unflat.c

@@ -18,16 +18,16 @@ static void test (void) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
     // set the cachetable to size 1 so that things won't fit.
     r=env->set_cachesize(env, 0, 1, 1);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_pagesize(db, 4096);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     u_int64_t i;

src/tests/keyrange.c

@@ -17,14 +17,14 @@ static void test (void) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_pagesize(db, 4096);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     u_int64_t i;

src/tests/manyfiles.c

@@ -16,11 +16,11 @@ static void
 test_setup (void) {
     system("rm -rf " ENVDIR);
     int r;
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
 
@@ -31,7 +31,7 @@ test_setup (void) {
 	snprintf(fname, sizeof(fname), "foo%d.db", i);
 	r=db_create(&dbs[i], env, 0); CKERR(r);
 	r = dbs[i]->set_pagesize(dbs[i], 4096);
-	r=dbs[i]->open(dbs[i], txn, fname, 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+	r=dbs[i]->open(dbs[i], txn, fname, 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     }
     r=txn->commit(txn, 0);    assert(r==0);
 }

src/tests/medium-nested-commit-commit.c

@@ -86,7 +86,7 @@ test_setup (void) {
     DB_TXN *txn;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       CKERR(r);
 
     r=db_env_create(&env, 0); CKERR(r);
     r=env->set_lk_max_locks(env, N); CKERR(r);
@@ -94,12 +94,12 @@ test_setup (void) {
     r=env->set_lk_max_objects(env, N); CKERR(r);
 #endif
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 }
 

src/tests/test-recover1.c

@@ -11,7 +11,7 @@
 static void test (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);                                                     assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);                                                     assert(r==0);
 
     DB_ENV *env;
     DB_TXN *tid;
@@ -20,11 +20,11 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 
     r=db_create(&db, env, 0);                                                  CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);               CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);               CKERR(r);
     r=tid->commit(tid, 0);                                                     assert(r==0);
 
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
@@ -38,10 +38,10 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
     r=db_create(&db, env, 0);                                                  CKERR(r);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, 0777);                       CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO);                       CKERR(r);
     r=db->get(db, tid, dbt_init(&key, "a", 2), dbt_init_malloc(&data), 0);     assert(r==0); 
     r=tid->commit(tid, 0);                                                     assert(r==0);
     free(data.data);

src/tests/test-recover2.c

@@ -11,7 +11,7 @@
 static void test (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);                                                     assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);                                                     assert(r==0);
 
     DB_ENV *env;
     DB_TXN *tid;
@@ -20,11 +20,11 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 
     r=db_create(&db, env, 0);                                                  CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);               CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);               CKERR(r);
     r=tid->commit(tid, 0);                                                     assert(r==0);
 
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
@@ -48,10 +48,10 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
     r=db_create(&db, env, 0);                                                  CKERR(r);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, 0777);                       CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO);                       CKERR(r);
     for (i=0; i<N; i++) {
 	r=db->get(db, tid, dbt_init(&key, keys[i], 1+strlen(keys[i])), dbt_init_malloc(&data), 0);     assert(r==0);
 	assert(strcmp(data.data, vals[i])==0);

src/tests/test-recover3.c

@@ -16,7 +16,7 @@
 static void test (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);                                                     assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);                                                     assert(r==0);
 
     DB_ENV *env;
     DB_TXN *tid;
@@ -25,11 +25,11 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 
     r=db_create(&db, env, 0);                                                  CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);               CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);               CKERR(r);
     r=tid->commit(tid, 0);                                                     assert(r==0);
 
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
@@ -57,10 +57,10 @@ static void test (void) {
 
     r=db_env_create(&env, 0);                                                  assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD|DB_RECOVER, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0);                                         assert(r==0);
     r=db_create(&db, env, 0);                                                  CKERR(r);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, 0777);                       CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO);                       CKERR(r);
     for (i=0; i<N; i++) {
 	r=db->get(db, tid, dbt_init(&key, keys[i], 1+strlen(keys[i])), dbt_init_malloc(&data), 0);     assert(r==0);
 	assert(strcmp(data.data, vals[i])==0);

src/tests/test938.c

@@ -121,19 +121,19 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int r;
 
     DB_TXN *txn;
     {
         r = db_env_create(&env, 0);                                   CKERR(r);
-	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	env->set_errfile(env, stderr);
 	r=env->txn_begin(env, 0, &txn, 0);                            CKERR(r);
 	r=db_create(&db, env, 0);                                     CKERR(r);
 	r=db->set_flags(db, DB_DUP|DB_DUPSORT);
-	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);  CKERR(r);
+	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);  CKERR(r);
 	r=txn->commit(txn, 0);                                        CKERR(r);
     }
     int i;

src/tests/test938b.c

@@ -53,19 +53,19 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int r;
 
     DB_TXN *txn;
     {
         r = db_env_create(&env, 0);                                   CKERR(r);
-	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	env->set_errfile(env, stderr);
 	r=env->txn_begin(env, 0, &txn, 0);                            CKERR(r);
 	r=db_create(&db, env, 0);                                     CKERR(r);
 	r=db->set_flags(db, DB_DUP|DB_DUPSORT);
-	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);  CKERR(r);
+	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);  CKERR(r);
 	r=txn->commit(txn, 0);                                        CKERR(r);
     }
     run();

src/tests/test938c.c

@@ -54,19 +54,19 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int r;
 
     DB_TXN *txn;
     {
         r = db_env_create(&env, 0);                                   CKERR(r);
-	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	env->set_errfile(env, stderr);
 	r=env->txn_begin(env, 0, &txn, 0);                            CKERR(r);
 	r=db_create(&db, env, 0);                                     CKERR(r);
 	r=db->set_flags(db, DB_DUP|DB_DUPSORT);
-	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);  CKERR(r);
+	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);  CKERR(r);
 	r=txn->commit(txn, 0);                                        CKERR(r);
     }
     run();

src/tests/test944.c

@@ -111,19 +111,19 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int r;
 
     DB_TXN *txn;
     {
         r = db_env_create(&env, 0);                                   CKERR(r);
-	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	env->set_errfile(env, stderr);
 	r=env->txn_begin(env, 0, &txn, 0);                            CKERR(r);
 	r=db_create(&db, env, 0);                                     CKERR(r);
 	r=db->set_flags(db, DB_DUP|DB_DUPSORT);
-	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);  CKERR(r);
+	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);  CKERR(r);
 	r=txn->commit(txn, 0);                                        CKERR(r);
     }
     int i;

src/tests/test944a.c

@@ -108,18 +108,18 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int r;
 
     DB_TXN *txn;
     {
         r = db_env_create(&env, 0);                                   CKERR(r);
-	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+	r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	env->set_errfile(env, stderr);
 	r=env->txn_begin(env, 0, &txn, 0);                            CKERR(r);
 	r=db_create(&db, env, 0);                                     CKERR(r);
-	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777);  CKERR(r);
+	r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);  CKERR(r);
 	r=txn->commit(txn, 0);                                        CKERR(r);
     }
     int i;

src/tests/test_789.c

@@ -15,7 +15,7 @@ test_789(void) {
 
     /* setup test directory */
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     /* setup environment */
     DB_ENV *env;
@@ -24,7 +24,7 @@ test_789(void) {
         r = env->set_data_dir(env, ENVDIR);
         r = env->set_lg_dir(env, ENVDIR);
         env->set_errfile(env, stdout);
-        r = env->open(env, 0, DB_INIT_MPOOL + DB_INIT_LOG + DB_INIT_LOCK + DB_INIT_TXN + DB_PRIVATE + DB_CREATE, 0777); 
+        r = env->open(env, 0, DB_INIT_MPOOL + DB_INIT_LOG + DB_INIT_LOCK + DB_INIT_TXN + DB_PRIVATE + DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); 
         assert(r == 0);
     }
 
@@ -35,7 +35,7 @@ test_789(void) {
         r = env->txn_begin(env, 0, &txn, 0); assert(r == 0);
 
         r = db_create(&db, env, 0); assert(r == 0);
-        r = db->open(db, txn, "test.db", 0, DB_BTREE, DB_CREATE, 0777); assert(r == 0);
+        r = db->open(db, txn, "test.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r == 0);
 
         r = txn->commit(txn, 0); assert(r == 0);
     }

src/tests/test_935.c

@@ -17,7 +17,7 @@ testit (const int klen, const int vlen, const int n, const int lastvlen) {
 
     // setup test directory
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     // setup environment
     DB_ENV *env;
@@ -26,7 +26,7 @@ testit (const int klen, const int vlen, const int n, const int lastvlen) {
         r = env->set_data_dir(env, ENVDIR);
         r = env->set_lg_dir(env, ENVDIR);
         env->set_errfile(env, stdout);
-        r = env->open(env, 0, DB_INIT_MPOOL + DB_PRIVATE + DB_CREATE, 0777); 
+        r = env->open(env, 0, DB_INIT_MPOOL + DB_PRIVATE + DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); 
         assert(r == 0);
     }
 
@@ -35,7 +35,7 @@ testit (const int klen, const int vlen, const int n, const int lastvlen) {
     {
         DB_TXN *txn = 0;
         r = db_create(&db, env, 0); assert(r == 0);
-        r = db->open(db, txn, "test.db", 0, DB_BTREE, DB_CREATE, 0777); assert(r == 0);
+        r = db->open(db, txn, "test.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r == 0);
     }
 
     // insert to fill up a node

src/tests/test_abort1.c

@@ -23,15 +23,15 @@ test_db_open_aborts (void) {
 
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 #if 0
     {
 	DB_TXN *tid;
 	r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-	r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+	r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	r=tid->abort(tid);        assert(r==0);
     }
     {
@@ -77,15 +77,15 @@ test_db_put_aborts (void) {
 
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     {
 	DB_TXN *tid;
 	r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-	r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+	r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 	r=tid->commit(tid,0);        assert(r==0);
     }
     {

src/tests/test_abort2.c

@@ -30,15 +30,15 @@ static void
 do_test_abort2 (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_pagesize(db, 4096); // Use a small page
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
@@ -57,10 +57,10 @@ do_test_abort2 (void) {
     // Now do a few inserts that abort.
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); CKERR(r);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 #ifndef TOKUDB
     {
 	u_int32_t ps;
@@ -89,7 +89,7 @@ do_test_abort2 (void) {
     //printf("%s:%d\n", __FILE__, __LINE__);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0); CKERR(r);
     //printf("%s:%d\n", __FILE__, __LINE__);
 

src/tests/test_abort3.c

@@ -66,15 +66,15 @@ static void
 test_abort3 (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     insert(0, 0);
     r=txn->commit(txn, 0);    assert(r==0);
 

src/tests/test_abort_delete_first.c

@@ -81,15 +81,15 @@ do_abort_delete_first_or_last(int N,
 			      ) {
     int r,i;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_pagesize(db, 4096); // Use a small page
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    assert(r==0);
 
     // First fill up the db

src/tests/test_archive0.c

@@ -14,14 +14,14 @@ int main (int argc, const char *argv[]) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); CKERR(r);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    CKERR(r);
 
     char **list;

src/tests/test_archive1.c

@@ -12,15 +12,15 @@ int main (int argc, const char *argv[]) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
     r=env->set_lg_max(env, 16000); CKERR(r);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); CKERR(r);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    CKERR(r);
 
     int i;

src/tests/test_archive2.c

@@ -13,21 +13,21 @@ int main (int argc, const char *argv[]) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); CKERR(r);
     env->set_errfile(env, stderr);
     r=env->set_lg_max(env, 20000); CKERR(r);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
 
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); CKERR(r);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    CKERR(r);
 
     r=db_create(&db2, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &txn, 0); CKERR(r);
-    r=db->open(db2, txn, "foo2.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db2, txn, "foo2.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=txn->commit(txn, 0);    CKERR(r);
 
     r=env->txn_begin(env, 0, &txn2, 0); CKERR(r);

src/tests/test_cursor_2.c

@@ -26,7 +26,7 @@ test_cursor (void) {
     /* create the dup database file */
     r = db_env_create(&env, 0);        assert(r == 0);
     env->set_errfile(env, stderr);
-    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, 0777); CKERR(r);
+    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r = db_create(&db, env, 0); assert(r == 0);
     db->set_errfile(db,stderr); // Turn off those annoying errors
     r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666); assert(r == 0);
@@ -83,7 +83,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test_cursor();
 

src/tests/test_cursor_3.c

@@ -59,7 +59,7 @@ test (void) {
     /* create the dup database file */
     r = db_env_create(&env, 0);        assert(r == 0);
     env->set_errfile(env, stderr);
-    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, 0777); CKERR(r);
+    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r = db_create(&db, env, 0); assert(r == 0);
     db->set_errfile(db,stderr); // Turn off those annoying errors
     r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666); assert(r == 0);
@@ -95,7 +95,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test();
 

src/tests/test_cursor_DB_NEXT_no_dup.c

@@ -23,12 +23,12 @@ static DB_TXN* null_txn = NULL;
 static void setup_env(void) {
     assert(!env && !db && !cursor);
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     r = db_env_create(&env, 0);
         CKERR(r);
     assert(env);
     env->set_errfile(env, stderr);
-    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, 0777);
+    r = env->open(env, ENVDIR, DB_CREATE|DB_INIT_MPOOL|DB_THREAD|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO);
         CKERR(r);
     assert(env);
 }

src/tests/test_cursor_db_current.c

@@ -120,7 +120,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     test_cursor_current();
     test_reopen();

src/tests/test_cursor_delete2.c

@@ -65,7 +65,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test_cursor_delete2();
 

src/tests/test_cursor_delete2a.c

@@ -67,7 +67,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test_cursor_delete2();
 

src/tests/test_cursor_delete_next.c

@@ -25,7 +25,7 @@ setup_db (char* name) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     r = db_env_create(&env, 0);                     CKERR(r);
     r = env->open(env, ENVDIR, DB_CREATE | DB_PRIVATE | DB_INIT_MPOOL, 0666);  CKERR(r);

src/tests/test_cursor_flags.c

@@ -45,7 +45,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test_cursor_flags(0, 0);
     test_cursor_flags(~0, EINVAL);

src/tests/test_cursor_nonleaf_expand.c

@@ -92,7 +92,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    int r=mkdir(ENVDIR, 0777); assert(r==0);
+    int r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     int i;
     for (i=1; i<=65536; i *= 2) {

src/tests/test_cursor_null.c

@@ -111,7 +111,7 @@ setup_dbs (u_int32_t dup_flags) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     dbenv   = NULL;
     db      = NULL;
     /* Open/create primary */

src/tests/test_db_already_exists.c

@@ -22,7 +22,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
     r=chdir(ENVDIR);       assert(r==0);
 
     r = db_create(&db, null_env, 0);                                         CKERR(r);

src/tests/test_db_assoc3.c

@@ -557,7 +557,7 @@ int main (int argc, const char *argv[]) {
     switch (mode) {
     case MODE_DEFAULT:
 	system("rm -rf " ENVDIR);
-	mkdir(ENVDIR, 0777); 
+	toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); 
 	create_databases();
 	{
 	    int i;

src/tests/test_db_close_no_open.c

@@ -19,9 +19,9 @@ DB *db;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_PRIVATE|DB_CREATE, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
     r=db_create(&db, env, 0); assert(r==0);
     r=db->close(db, 0);       assert(r==0);
     r=env->close(env, 0);     assert(r==0);

src/tests/test_db_current_clobbers_db.c

@@ -20,9 +20,9 @@ DB_TXN* null_txn = NULL;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);    CKERR(r);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);    CKERR(r);
     r=db_env_create(&env, 0); CKERR(r);
-    r=env->open(env, ENVDIR, DB_PRIVATE|DB_INIT_MPOOL|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_PRIVATE|DB_INIT_MPOOL|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r = db->open(db, null_txn, "foo.db", "main", DB_BTREE, DB_CREATE, 0666); CKERR(r);
     DBC *cursor;

src/tests/test_db_curs2.c

@@ -530,7 +530,7 @@ int main (int argc, const char *argv[]) {
     case MODE_DEFAULT:
 	oppass=1;
 	system("rm -rf " ENVDIR);
-	mkdir(ENVDIR, 0777); 
+	toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); 
 	create_databases();
 	{
 	    int i;

src/tests/test_db_cursor.c

@@ -335,7 +335,7 @@ int main (int argc, const char *argv[]) {
     case MODE_DEFAULT:
 	opnum=0;
 	system("rm -rf " ENVDIR);
-	mkdir(ENVDIR, 0777); 
+	toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); 
 	create_databases();
 	{
 	    int i;

src/tests/test_db_dbt_appmalloc.c

@@ -141,7 +141,7 @@ int main(int argc, const char *argv[]) {
     
     parse_args(argc, argv);
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     second_setup();
     for (i = 0; i < 2; i++) {
         callback_set_malloc = i & 0x1;

src/tests/test_db_dbt_malloc_leak.c

@@ -83,7 +83,7 @@ static void second_setup (u_int32_t dupflags) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     dbenv = 0;
     /* Open/create primary */
     r = db_create(&db, dbenv, 0);                                               CKERR(r);

src/tests/test_db_dbt_mem_behavior.c

@@ -28,7 +28,7 @@ setup(void) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     dbenv = 0;
     /* Open/create primary */
     r = db_create(&db, dbenv, 0);                                               CKERR(r);

src/tests/test_db_delboth.c

@@ -53,7 +53,7 @@ test_db_delboth (int n, int dup_mode) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0);

src/tests/test_db_delete.c

@@ -47,7 +47,7 @@ test_db_delete (int n, int dup_mode) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0);
@@ -113,7 +113,7 @@ test_db_get_datasize0 (void) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0);

src/tests/test_db_donotindex.c

@@ -130,7 +130,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
     for (i = 0; i < (1<<3); i++) {
         system("rm -rf " ENVDIR);
-        mkdir(ENVDIR, 0777);
+        toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
         second_setup();
 
         check_secondary(DB_NOTFOUND);

src/tests/test_db_env_open_dir_priority.c

@@ -43,17 +43,17 @@ reinit_config (int set_home, int set_DB_ENVIRON, int set_DB_HOME) {
     r = fchdir(rootfd);                 assert(r == 0);
 
     r = system("rm -rf " ENVDIR);          assert(r == 0);
-    r = mkdir(ENVDIR, 0777);               assert(r == 0);
+    r = toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);               assert(r == 0);
     r = chdir(ENVDIR);                     assert(r == 0);
     unsetenv(DB_HOME);
 
     if (set_home) {
         db_dir = "home";
-        r = mkdir(db_dir, 0777);        assert(r == 0);
+        r = toku_os_mkdir(db_dir, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r == 0);
     }
     else if (set_DB_ENVIRON && set_DB_HOME) {
         db_dir = "DB_HOME";
-        r = mkdir(db_dir, 0777);        assert(r == 0);
+        r = toku_os_mkdir(db_dir, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r == 0);
     }
     else db_dir = ".";
     

src/tests/test_db_env_open_nocreate.c

@@ -43,7 +43,7 @@ int main() {
 	dbenv->close(dbenv,0); // free memory
 	
 	system("rm -rf " ENVDIR);
-	mkdir(ENVDIR, 0777);
+	toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 	r = db_env_create(&dbenv, 0);
 	CKERR(r);
 	r = dbenv->open(dbenv, ENVDIR, private_flags|DB_INIT_MPOOL, 0);
@@ -62,7 +62,7 @@ int main() {
     // Now make sure that if we have a non-private DB that we can tell if it opened or not.
     DB *db;
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     r = db_env_create(&dbenv, 0);
     CKERR(r);
     r = dbenv->open(dbenv, ENVDIR, DB_CREATE|DB_INIT_MPOOL, 0);

src/tests/test_db_env_open_open_close.c

@@ -21,7 +21,7 @@ int main(int argc, char** argv) {
     if (argc == 2 && !strcmp(argv[1], "-v")) verbose = 1;
     
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r = db_env_create(&dbenv, 0);
     assert(r == 0);

src/tests/test_db_env_set_data_dir.c

@@ -18,7 +18,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     r = db_env_create(&dbenv, 0); assert(r == 0);
 
@@ -39,7 +39,7 @@ int main() {
     DB *db;
     r = db_create(&db, dbenv, 0); assert(r == 0);
 
-    r = db->open(db, 0, "test.db", "main", DB_BTREE, DB_CREATE, 0777); assert(r == 0);
+    r = db->open(db, 0, "test.db", "main", DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r == 0);
     
     r = db->close(db, 0); assert(r == 0);
     

src/tests/test_db_env_set_errpfx.c

@@ -16,7 +16,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     r = db_env_create(&dbenv, 0);
     assert(r == 0);

src/tests/test_db_env_set_lg_dir.c

@@ -19,7 +19,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     r = db_env_create(&dbenv, 0);
     assert(r == 0);

src/tests/test_db_env_set_tmp_dir.c

@@ -19,7 +19,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     r = db_env_create(&dbenv, 0);
     assert(r == 0);

src/tests/test_db_env_strdup_null.c

@@ -19,12 +19,12 @@ DB *db;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     r=system("rm -rf " ENVDIR);                    assert(r==0);
-    r=mkdir(ENVDIR, 0777);                         assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);                         assert(r==0);
     r=db_env_create(&env, 0);                   assert(r==0);
 // None of this stuff works with BDB.  TDB does more error checking.
 #ifdef USE_TDB
     r=env->set_data_dir(env, NULL);             assert(r==EINVAL);
-    r=env->open(env, ENVDIR, DB_PRIVATE, 0777);    assert(r==0);
+    r=env->open(env, ENVDIR, DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO);    assert(r==0);
     env->set_errpfx(env, NULL);                 assert(1); //Did not crash.
     r=env->set_tmp_dir(env, NULL);              assert(r==EINVAL);
 #endif

src/tests/test_db_get_put_flags.c

@@ -59,7 +59,7 @@ setup (u_int32_t flags) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     /* Open/create primary */
     r = db_create(&dbp, dbenv, 0);                                              CKERR(r);
     dbp->set_errfile(dbp,0); // Turn off those annoying errors

src/tests/test_db_open_notexist_reopen.c

@@ -19,9 +19,9 @@ DB *db;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);                                                           assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);                                                           assert(r==0);
     r=db_env_create(&env, 0);                                                     CKERR(r);
-    r=env->open(env, ENVDIR, DB_PRIVATE|DB_INIT_MPOOL|DB_CREATE, 0777);                         CKERR(r);
+    r=env->open(env, ENVDIR, DB_PRIVATE|DB_INIT_MPOOL|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO);                         CKERR(r);
     r=db_create(&db, env, 0);                                                     CKERR(r);
     r=db->open(db, NULL, "doesnotexist.db", "testdb", DB_BTREE, 0, 0666);         assert(r==ENOENT);
     r=db->open(db, NULL, "doesnotexist.db", "testdb", DB_BTREE, DB_CREATE, 0666); CKERR(r);

src/tests/test_db_remove_memleak.c

@@ -22,14 +22,14 @@ DBT data;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);         assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);         assert(r==0);
     memset(&key, 0, sizeof(key));
     memset(&data, 0, sizeof(data));
     key.size = sizeof("name");
     key.data = "name";
     
     r=db_env_create(&env, 0);   assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r=db_create(&db, env, 0);   assert(r==0);
     r=db->open(db, NULL, "master.db", NULL, DB_BTREE, DB_CREATE, 0666); assert(r==0);

src/tests/test_db_remove_subdb.c

@@ -22,7 +22,7 @@ DBT data;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);         assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);         assert(r==0);
     memset(&key, 0, sizeof(key));
     memset(&data, 0, sizeof(data));
     key.size = sizeof("name");
@@ -30,7 +30,7 @@ int main (int UU(argc), char UU(*argv[])) {
     
     r=db_env_create(&env, 0);   assert(r==0);
     // Note: without DB_INIT_MPOOL the BDB library will fail on db->open().
-    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r=db_create(&db, env, 0);   assert(r==0);
     r=db->remove(db, "DoesNotExist.db", NULL, 0);       assert(r==ENOENT);

src/tests/test_db_secondary.c

@@ -192,7 +192,7 @@ int main() {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     second_setup();
     insert_test();

src/tests/test_db_set_flags.c

@@ -38,7 +38,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     test_db_set_flags(0, 0, 0, 0);
     test_db_set_flags(0, 0, DB_DUP, EINVAL);

src/tests/test_db_subdb.c

@@ -22,11 +22,11 @@ int main() {
 
     system("rm -rf " ENVDIR);
 
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r=db_env_create(&env, 0);   assert(r==0);
     // Note: without DB_INIT_MPOOL the BDB library will fail on db->open().
-    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE|DB_INIT_LOG, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE|DB_INIT_LOG, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r = db_create(&db, env, 0);
     CKERR(r);

src/tests/test_db_subdb_different_flags.c

@@ -22,11 +22,11 @@ int main() {
 
     system("rm -rf " ENVDIR);
 
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r=db_env_create(&env, 0);   assert(r==0);
     // Note: without DB_INIT_MPOOL the BDB library will fail on db->open().
-    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE|DB_INIT_LOG, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_INIT_MPOOL|DB_PRIVATE|DB_CREATE|DB_INIT_LOG, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     r = db_create(&db, env, 0);                                              CKERR(r);
     r = db->open(db, null_txn, fname, "main", DB_BTREE, DB_CREATE, 0666);    CKERR(r);

src/tests/test_db_txn_locks.c

@@ -187,7 +187,7 @@ setup_dbs (u_int32_t dup_flags) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     dbenv   = NULL;
     db      = NULL;
     /* Open/create primary */

src/tests/test_db_txn_locks_read_uncommitted.c

@@ -86,7 +86,7 @@ setup_dbs (u_int32_t dup_flags) {
     int r;
 
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     dbenv   = NULL;
     db      = NULL;
     /* Open/create primary */

src/tests/test_dup_delete.c

@@ -723,7 +723,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
 #ifdef USE_BDB
     /* dup tests */

src/tests/test_dup_dup.c

@@ -227,7 +227,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     test_put_00_01_01(0, 0); 
     test_put_00_01_01(0, DB_NOOVERWRITE); 

src/tests/test_dup_flags.c

@@ -73,7 +73,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     /* test flags */
     test_dup_flags(0);

src/tests/test_dup_insert.c

@@ -255,7 +255,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     
     /* nodup tests */
     for (i = 1; i <= (1<<16); i *= 2) {

src/tests/test_dup_next.c

@@ -133,7 +133,7 @@ int main(int argc, const char *argv[]) {
     }
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     for (i = 1; i <= 65536; i = testlevel ? i+1 : i*2) {
         test_dup_next(i, DB_DUP + DB_DUPSORT);

src/tests/test_dup_search.c

@@ -326,7 +326,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_dupsort_del.c

@@ -71,16 +71,16 @@ static void
 test_dupsort_del (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     insert(0, 0);
     insert(0, 1);
     r=txn->commit(txn, 0);    assert(r==0);

src/tests/test_dupsort_del_checksum.c

@@ -73,16 +73,16 @@ static void
 test_abort3 (void) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
 
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
 
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     insert(0, 0);
     insert(0, 1);
     r=txn->commit(txn, 0);    assert(r==0);
@@ -99,7 +99,7 @@ test_abort3 (void) {
     r=db_create(&db, env, 0); CKERR(r);
     r=db->set_flags(db, DB_DUPSORT);
     r=env->txn_begin(env, 0, &txn, 0); assert(r==0);
-    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, 0777); CKERR(r);
+    r=db->open(db, txn, "foo.db", 0, DB_BTREE, 0, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     lookup(0, 0, 1);
     r=txn->commit(txn, 0); CKERR(r);
     r=db->close(db, 0); CKERR(r);

src/tests/test_dupsort_delete.c

@@ -102,7 +102,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
     //   test_dupsort_delete(256); return 0;
     
     /* nodup tests */

src/tests/test_dupsort_get.c

@@ -124,7 +124,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_dupsort_get_both.c

@@ -149,7 +149,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_dupsort_get_both_range.c

@@ -155,7 +155,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_dupsort_set.c

@@ -150,7 +150,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_dupsort_set_range.c

@@ -157,7 +157,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     int limit = 1<<13;
     if (verbose > 1)

src/tests/test_env_close_flags.c

@@ -18,12 +18,12 @@ int main (int argc __attribute__((__unused__)), char *argv[]  __attribute__((__u
     DB_ENV *env;
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);        assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r==0);
     r=db_env_create(&env, 0);  assert(r==0);
     env->set_errfile(env,0); // Turn off those annoying errors
     r=env->close   (env, 0);   assert(r==0);
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);        assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r==0);
     r=db_env_create(&env, 0);  assert(r==0);
     env->set_errfile(env,0); // Turn off those annoying errors
     r=env->close   (env, 1);  
@@ -34,19 +34,19 @@ int main (int argc __attribute__((__unused__)), char *argv[]  __attribute__((__u
     assert(r==0);
 #endif
     system("rm -rf " ENVDIR); 
-    r=mkdir(ENVDIR, 0777);        assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r==0);
 
     r=db_env_create(&env, 0);  assert(r==0);
     env->set_errfile(env,0); // Turn off those annoying errors
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=env->close   (env, 0);  assert(r==0);
     
     system("rm -rf " ENVDIR); 
-    r=mkdir(ENVDIR, 0777);        assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);        assert(r==0);
 
     r=db_env_create(&env, 0);  assert(r==0);
     env->set_errfile(env,0); // Turn off those annoying errors
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=env->close   (env, 1);
     //BDB does not check this.
 #if defined(USE_TDB) || (DB_VERSION_MAJOR == 4 && DB_VERSION_MINOR >= 3)

src/tests/test_env_open_flags.c

@@ -36,7 +36,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
 #ifdef USE_TDB
     toku_set_trace_file(ENVDIR "/trace.tktrace");

src/tests/test_error.c

@@ -21,7 +21,7 @@ int main (int argc, const char *argv[]) {
 #else
     
     system("rm -rf " ENVDIR);
-    int r=mkdir(ENVDIR, 0777); assert(r==0);
+    int r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     {
 	DB_ENV *env;

src/tests/test_get_both_range.c

@@ -168,7 +168,7 @@ int main(int argc, const char *argv[]) {
 	snprintf(rmcmd, sizeof(rmcmd), "rm -rf %s", annotated_envdir);
 	system(rmcmd);
     }
-    mkdir(annotated_envdir, 0777);
+    toku_os_mkdir(annotated_envdir, S_IRWXU+S_IRWXG+S_IRWXO);
 
     if (doi==0) { 
 	for (i=1; i <= 256; i *= 2) {

src/tests/test_get_zeroed_dbt.c

@@ -34,7 +34,7 @@ test_get (int dup_mode) {
 int main (int argc, const char *argv[]) {
     parse_args(argc, argv);
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     test_get(0);
     test_get(DB_DUP + DB_DUPSORT);

src/tests/test_groupcommit_count.c

@@ -39,10 +39,10 @@ test_groupcommit (int nthreads) {
     DB_TXN *tid;
 
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=tid->commit(tid, 0);    assert(r==0);
 
     int i;
@@ -108,7 +108,7 @@ int main (int argc, const char *argv[]) {
     { int r = db_env_set_func_fsync(do_fsync); CKERR(r); }
 
     system("rm -rf " ENVDIR);
-    { int r=mkdir(ENVDIR, 0777);       assert(r==0); }
+    { int r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0); }
 
     test_groupcommit(1);  printtdiff("1 thread");
     test_groupcommit(2);  printtdiff("2 threads");

src/tests/test_groupcommit_perf.c

@@ -39,10 +39,10 @@ test_groupcommit (int nthreads) {
     DB_TXN *tid;
 
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|DB_THREAD, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=tid->commit(tid, 0);    assert(r==0);
 
     int i;
@@ -97,7 +97,7 @@ int main (int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    { int r=mkdir(ENVDIR, 0777);       assert(r==0); }
+    { int r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0); }
 
     gettimeofday(&prevtime, 0);
     test_groupcommit(1);  printtdiff("1 thread");

src/tests/test_hsoc.c

@@ -49,7 +49,7 @@ test_hsoc (int pagesize, int dup_mode) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0); assert(r == 0);

src/tests/test_insert_cursor_delete_insert.c

@@ -68,7 +68,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
   
     system("rm -rf " ENVDIR);
-    mkdir(ENVDIR, 0777);
+    toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);
 
     test_insert_delete_insert(0);
     test_insert_delete_insert(DB_DUP + DB_DUPSORT);

src/tests/test_insert_memleak.c

@@ -48,7 +48,7 @@ int main(int argc, const char *argv[]) {
     parse_args(argc, argv);
 
     system("rm -rf " ENVDIR);
-    int r=mkdir(ENVDIR, 0777); assert(r==0);
+    int r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     test_insert(256, 0);
 

src/tests/test_kv_limits.c

@@ -26,7 +26,7 @@ test_key_size_limit (int dup_mode) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0);
@@ -82,7 +82,7 @@ test_data_size_limit (int dup_mode) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777); assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
 
     /* create the dup database file */
     r = db_create(&db, null_env, 0);

src/tests/test_log0.c

@@ -18,9 +18,9 @@ DB_ENV *env;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); assert(r==0);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); assert(r==0);
     r=env->close(env, 0); assert(r==0);
     return 0;
 }

src/tests/test_log1.c

@@ -23,12 +23,12 @@ DB_TXN *tid;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     {
 	DBT key,data;
 	memset(&key, 0, sizeof(key));

src/tests/test_log10.c

@@ -35,10 +35,10 @@ static void insert_some (int outeri) {
     DB_TXN *tid;
     r=db_env_create(&env, 0); assert(r==0);
     r=env->set_lk_max_locks(env, 2*maxcount); CKERR(r);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|create_flag, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE|create_flag, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, create_flag, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, create_flag, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=tid->commit(tid, 0);    assert(r==0);
 
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
@@ -80,13 +80,13 @@ static void make_db (void) {
     int i;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
     r=env->set_lk_max_locks(env, 2*maxcount); CKERR(r);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=tid->commit(tid, 0);    assert(r==0);
     r=db->close(db, 0);  CKERR(r);
     r=env->close(env, 0); CKERR(r);

src/tests/test_log1_abort.c

@@ -24,12 +24,12 @@ DB_TXN *tid;
 int main (int UU(argc), char UU(*argv[])) {
     int r;
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_PRIVATE|DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     {
 	DBT key,data;
 	memset(&key, 0, sizeof(key));

src/tests/test_log2.c

@@ -22,13 +22,13 @@ static void make_db (void) {
     int r;
 
     system("rm -rf " ENVDIR);
-    r=mkdir(ENVDIR, 0777);       assert(r==0);
+    r=toku_os_mkdir(ENVDIR, S_IRWXU+S_IRWXG+S_IRWXO);       assert(r==0);
     r=db_env_create(&env, 0); assert(r==0);
     env->set_errfile(env, stderr);
-    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, 0777); CKERR(r);
+    r=env->open(env, ENVDIR, DB_INIT_LOCK|DB_INIT_LOG|DB_INIT_MPOOL|DB_INIT_TXN|DB_CREATE|DB_PRIVATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=db_create(&db, env, 0); CKERR(r);
     r=env->txn_begin(env, 0, &tid, 0); assert(r==0);
-    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, 0777); CKERR(r);
+    r=db->open(db, tid, "foo.db", 0, DB_BTREE, DB_CREATE, S_IRWXU+S_IRWXG+S_IRWXO); CKERR(r);
     r=tid->commit(tid, 0);    assert(r==0);
     r=db->close(db, 0);       assert(r==0);
     r=env->close(env, 0);     assert(r==0);