Index: common.scm
==================================================================
--- common.scm
+++ common.scm
@@ -640,10 +640,11 @@
   (thread-sleep! 0.05) ;; delay for startup
   (let ((legacy-sync (common:run-sync?))
 	(debug-mode  (debug:debug-mode 1))
 	(last-time   (current-seconds))
         (this-wd-num     (begin (mutex-lock! *wdnum*mutex) (let ((x *wdnum*)) (set! *wdnum* (add1 *wdnum*)) (mutex-unlock! *wdnum*mutex) x))))
+    (debug:print-info 2 *default-log-port* "Periodic sync thread started.")
     (debug:print-info 3 *default-log-port* "watchdog starting. legacy-sync is " legacy-sync" pid="(current-process-id)" this-wd-num="this-wd-num)
     (if (and legacy-sync (not *time-to-exit*))
 	(let* (;;(dbstruct (db:setup))
 	       (mtdb     (dbr:dbstruct-mtdb dbstruct))
 	       (mtpath   (db:dbdat-get-path mtdb)))

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -206,34 +206,46 @@
 
 ;; open an sql database inside a file lock
 ;; returns: db existed-prior-to-opening
 ;; RA => Returns a db handler; sets the lock if opened in writable mode
 ;;
+;;(define *db-open-mutex* (make-mutex))
+
 (define (db:lock-create-open fname initproc)
   (let* ((parent-dir   (or (pathname-directory fname)(current-directory))) ;; no parent? go local
 	 (dir-writable (file-write-access? parent-dir))
 	 (file-exists  (file-exists? fname))
 	 (file-write   (if file-exists
 			   (file-write-access? fname)
 			   dir-writable )))
+    ;;(mutex-lock! *db-open-mutex*) ;; tried this mutex, not clear it helped.
     (if file-write ;; dir-writable
 	(let (;; (lock    (obtain-dot-lock fname 1 5 10))
 	      (db      (sqlite3:open-database fname)))
 	  (sqlite3:set-busy-handler! db (make-busy-timeout 136000))
 	  ;; (db:set-sync db)
 	  (sqlite3:execute db "PRAGMA synchronous = 0;")
 	  (if (not file-exists)
-	      (begin
-		(if (string-match "^/tmp/.*" fname) ;; this is a file in /tmp
+              (begin
+		(if (and (configf:lookup *configdat* "setup" "use-wal")
+                         (string-match "^/tmp/.*" fname)) ;; this is a file in /tmp
 		    (sqlite3:execute db "PRAGMA journal_mode=WAL;")
 		    (print "Creating " fname " in NON-WAL mode."))
 		(initproc db)))
 	  ;; (release-dot-lock fname)
+          ;;(mutex-unlock! *db-open-mutex*)
 	  db)
 	(begin
 	  (debug:print 2 *default-log-port* "WARNING: opening db in non-writable dir " fname)
-	  (sqlite3:open-database fname))))) ;; )
+	  (let ((db (sqlite3:open-database fname)))
+            ;;(mutex-unlock! *db-open-mutex*)
+            db))))) ;; )
+
+
+
+
+
 
 ;; ;; This routine creates the db. It is only called if the db is not already opened
 ;; ;; 
 ;; (define (db:open-rundb dbstruct run-id #!key (attemptnum 0)(do-not-open #f)) ;;  (conc *toppath* "/megatest.db") (car *configinfo*)))
 ;;   (let* ((dbfile       (db:dbfile-path run-id)) ;; (conc toppath "/db/" run-id ".db"))
@@ -342,15 +354,16 @@
 ;; Open the classic megatest.db file (defaults to open in toppath)
 ;;
 ;;   NOTE: returns a dbdat not a dbstruct!
 ;;
 (define (db:open-megatest-db #!key (path #f)(name #f))
-  (let* ((dbpath       (conc (or path *toppath*) "/" (or name "megatest.db")))
+  (let* ((dbdir        (or path *toppath*))
+         (dbpath       (conc  dbdir "/" (or name "megatest.db")))
 	 (dbexists     (file-exists? dbpath))
 	 (db           (db:lock-create-open dbpath
 					    (lambda (db)
-					      (db:initialize-main-db db)
+                                              (db:initialize-main-db db)
 					      (db:initialize-run-id-db db))))
 	 (write-access (file-write-access? dbpath)))
     (debug:print-info 13 *default-log-port* "db:open-megatest-db "dbpath)
     (if (and dbexists (not write-access))
 	(set! *db-write-access* #f))
@@ -1054,10 +1067,12 @@
 		;;	   open-run-close-no-exception-handling
 ;;			   open-run-close-exception-handling)
 ;;)
 
 (define (db:initialize-main-db dbdat)
+  (when (not *configinfo*)
+           (launch:setup)) ;; added because Elena was getting stack dump because *configinfo* below was #f.
   (let* ((configdat (car *configinfo*))  ;; tut tut, global warning...
 	 (keys     (keys:config-get-fields configdat))
 	 (havekeys (> (length keys) 0))
 	 (keystr   (keys->keystr keys))
 	 (fieldstr (keys->key/field keys))

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -376,12 +376,30 @@
 ;;
 
 ;; TODO: for multiple areas, we will have multiple watchdogs; and multiple threads to manage
 (define *watchdog* (make-thread common:watchdog "Watchdog thread"))
 
-(if (not (args:get-arg "-server"))
-    (thread-start! *watchdog*)) ;; if starting a server; wait till we get to running state before kicking off watchdog
+;;(if (not (args:get-arg "-server"))
+;;    (thread-start! *watchdog*)) ;; if starting a server; wait till we get to running state before kicking off watchdog
+(let* ((no-watchdog-args
+       '("-list-runs"
+         "-list-servers"
+         "-server"
+         "-list-disks"
+         "-list-targets"
+         "-show-runconfig"
+         ;;"-list-db-targets"
+         "-show-runconfig"
+         "-show-config"
+         "-show-cmdinfo"))
+       (no-watchdog-args-vals (filter (lambda (x) x)
+                                      (map args:get-arg no-watchdog-args)))
+       (start-watchdog (null? no-watchdog-args-vals)))
+  ;;(BB> "no-watchdog-args="no-watchdog-args "no-watchdog-args-vals="no-watchdog-args-vals) 
+  (if start-watchdog
+      (thread-start! *watchdog*)))
+
 
 ;; bracket open-output-file with code to make leading directory if it does not exist and handle exceptions
 (define (open-logfile logpath)
   (condition-case
    (let* ((log-dir (or (pathname-directory logpath) ".")))