diff --git a/sim/mcuboot-sys/src/api.rs b/sim/mcuboot-sys/src/api.rs
index 78a1bbd..f38d98e 100644
--- a/sim/mcuboot-sys/src/api.rs
+++ b/sim/mcuboot-sys/src/api.rs
@@ -1,104 +1,190 @@
 //! HAL api for MyNewt applications
 
-use simflash::{Result, Flash, FlashPtr};
-use lazy_static::lazy_static;
+use crate::area::CAreaDesc;
 use libc;
 use log::{Level, log_enabled, warn};
+use simflash::{Result, Flash, FlashPtr};
 use std::{
+    cell::RefCell,
     collections::HashMap,
     mem,
-    ops::Deref,
+    ptr,
     slice,
-    sync::Mutex,
 };
 
 /// A FlashMap maintain a table of [device_id -> Flash trait]
 pub type FlashMap = HashMap<u8, FlashPtr>;
 
-lazy_static! {
-    static ref FLASH: Mutex<FlashMap> = {
-        Mutex::new(HashMap::new())
-    };
-}
-
-struct FlashParams {
+pub struct FlashParamsStruct {
     align: u8,
     erased_val: u8,
 }
 
-lazy_static! {
-    static ref FLASH_PARAMS: Mutex<HashMap<u8, FlashParams>> = {
-        Mutex::new(HashMap::new())
-    };
+pub type FlashParams = HashMap<u8, FlashParamsStruct>;
+
+pub struct CAreaDescPtr {
+   pub ptr: *const CAreaDesc,
+}
+
+pub struct FlashContext {
+    flash_map: FlashMap,
+    flash_params: FlashParams,
+    flash_areas: CAreaDescPtr,
+}
+
+impl FlashContext {
+    pub fn new() -> FlashContext {
+        FlashContext {
+            flash_map: HashMap::new(),
+            flash_params: HashMap::new(),
+            flash_areas: CAreaDescPtr{ptr: ptr::null()},
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Default)]
+pub struct CSimContext {
+    pub flash_counter: libc::c_int,
+    pub jumped: libc::c_int,
+    pub c_asserts: u8,
+    pub c_catch_asserts: u8,
+    // NOTE: Always leave boot_jmpbuf declaration at the end; this should
+    // store a "jmp_buf" which is arch specific and not defined by libc crate.
+    // The size below is enough to store data on a x86_64 machine.
+    pub boot_jmpbuf: [u64; 16],
+}
+
+pub struct CSimContextPtr {
+   pub ptr: *const CSimContext,
+}
+
+impl CSimContextPtr {
+    pub fn new() -> CSimContextPtr {
+        CSimContextPtr {
+            ptr: ptr::null(),
+        }
+    }
+}
+
+thread_local! {
+    pub static THREAD_CTX: RefCell<FlashContext> = RefCell::new(FlashContext::new());
+    pub static SIM_CTX: RefCell<CSimContextPtr> = RefCell::new(CSimContextPtr::new());
 }
 
 // Set the flash device to be used by the simulation.  The pointer is unsafely stashed away.
 pub unsafe fn set_flash(dev_id: u8, dev: &mut dyn Flash) {
-    let mut flash_params = FLASH_PARAMS.lock().unwrap();
-    flash_params.insert(dev_id, FlashParams {
-        align: dev.align() as u8,
-        erased_val: dev.erased_val(),
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow_mut().flash_params.insert(dev_id, FlashParamsStruct {
+            align: dev.align() as u8,
+            erased_val: dev.erased_val(),
+        });
+        let dev: &'static mut dyn Flash = mem::transmute(dev);
+        ctx.borrow_mut().flash_map.insert(
+            dev_id, FlashPtr{ptr: dev as *mut dyn Flash});
     });
-
-    let dev: &'static mut dyn Flash = mem::transmute(dev);
-    let mut flash = FLASH.lock().unwrap();
-    flash.insert(dev_id, FlashPtr{ptr: dev as *mut dyn Flash});
 }
 
 pub unsafe fn clear_flash(dev_id: u8) {
-    let mut flash = FLASH.lock().unwrap();
-    flash.remove(&dev_id);
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow_mut().flash_map.remove(&dev_id);
+    });
 }
 
 // This isn't meant to call directly, but by a wrapper.
 
 #[no_mangle]
+pub extern fn sim_get_flash_areas() -> *const CAreaDesc {
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow().flash_areas.ptr
+    })
+}
+
+#[no_mangle]
+pub extern fn sim_set_flash_areas(areas: *const CAreaDesc) {
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow_mut().flash_areas.ptr = areas;
+    });
+}
+
+#[no_mangle]
+pub extern fn sim_reset_flash_areas() {
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow_mut().flash_areas.ptr = ptr::null();
+    });
+}
+
+#[no_mangle]
+pub extern fn sim_get_context() -> *const CSimContext {
+    SIM_CTX.with(|ctx| {
+        ctx.borrow().ptr
+    })
+}
+
+#[no_mangle]
+pub extern fn sim_set_context(ptr: *const CSimContext) {
+    SIM_CTX.with(|ctx| {
+        ctx.borrow_mut().ptr = ptr;
+    });
+}
+
+#[no_mangle]
+pub extern fn sim_reset_context() {
+    SIM_CTX.with(|ctx| {
+        ctx.borrow_mut().ptr = ptr::null();
+    });
+}
+
+#[no_mangle]
 pub extern fn sim_flash_erase(dev_id: u8, offset: u32, size: u32) -> libc::c_int {
-    if let Ok(guard) = FLASH.lock() {
-        if let Some(flash) = guard.deref().get(&dev_id) {
+    let mut rc: libc::c_int = -19;
+    THREAD_CTX.with(|ctx| {
+        if let Some(flash) = ctx.borrow().flash_map.get(&dev_id) {
             let dev = unsafe { &mut *(flash.ptr) };
-            return map_err(dev.erase(offset as usize, size as usize));
+            rc = map_err(dev.erase(offset as usize, size as usize));
         }
-    }
-    -19
+    });
+    rc
 }
 
 #[no_mangle]
 pub extern fn sim_flash_read(dev_id: u8, offset: u32, dest: *mut u8, size: u32) -> libc::c_int {
-    if let Ok(guard) = FLASH.lock() {
-        if let Some(flash) = guard.deref().get(&dev_id) {
+    let mut rc: libc::c_int = -19;
+    THREAD_CTX.with(|ctx| {
+        if let Some(flash) = ctx.borrow().flash_map.get(&dev_id) {
             let mut buf: &mut[u8] = unsafe { slice::from_raw_parts_mut(dest, size as usize) };
             let dev = unsafe { &mut *(flash.ptr) };
-            return map_err(dev.read(offset as usize, &mut buf));
+            rc = map_err(dev.read(offset as usize, &mut buf));
         }
-    }
-    -19
+    });
+    rc
 }
 
 #[no_mangle]
 pub extern fn sim_flash_write(dev_id: u8, offset: u32, src: *const u8, size: u32) -> libc::c_int {
-    if let Ok(guard) = FLASH.lock() {
-        if let Some(flash) = guard.deref().get(&dev_id) {
+    let mut rc: libc::c_int = -19;
+    THREAD_CTX.with(|ctx| {
+        if let Some(flash) = ctx.borrow().flash_map.get(&dev_id) {
             let buf: &[u8] = unsafe { slice::from_raw_parts(src, size as usize) };
             let dev = unsafe { &mut *(flash.ptr) };
-            return map_err(dev.write(offset as usize, &buf));
+            rc = map_err(dev.write(offset as usize, &buf));
         }
-    }
-    -19
+    });
+    rc
 }
 
 #[no_mangle]
 pub extern fn sim_flash_align(id: u8) -> u8 {
-    let flash_params = FLASH_PARAMS.lock().unwrap();
-    let params = flash_params.get(&id).unwrap();
-    params.align
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow().flash_params.get(&id).unwrap().align
+    })
 }
 
 #[no_mangle]
 pub extern fn sim_flash_erased_val(id: u8) -> u8 {
-    let flash_params = FLASH_PARAMS.lock().unwrap();
-    let params = flash_params.get(&id).unwrap();
-    params.erased_val
+    THREAD_CTX.with(|ctx| {
+        ctx.borrow().flash_params.get(&id).unwrap().erased_val
+    })
 }
 
 fn map_err(err: Result<()>) -> libc::c_int {
diff --git a/sim/mcuboot-sys/src/c.rs b/sim/mcuboot-sys/src/c.rs
index 08b8813..6f92c34 100644
--- a/sim/mcuboot-sys/src/c.rs
+++ b/sim/mcuboot-sys/src/c.rs
@@ -2,37 +2,33 @@
 
 use crate::area::AreaDesc;
 use simflash::SimMultiFlash;
-use lazy_static::lazy_static;
 use libc;
 use crate::api;
-use std::sync::Mutex;
-
-lazy_static! {
-    /// Mutex to lock the simulation.  The C code for the bootloader uses
-    /// global variables, and is therefore non-reentrant.
-    static ref BOOT_LOCK: Mutex<()> = Mutex::new(());
-}
 
 /// Invoke the bootloader on this flash device.
 pub fn boot_go(multiflash: &mut SimMultiFlash, areadesc: &AreaDesc,
                counter: Option<&mut i32>, catch_asserts: bool) -> (i32, u8) {
-    let _lock = BOOT_LOCK.lock().unwrap();
-
     unsafe {
         for (&dev_id, flash) in multiflash.iter_mut() {
             api::set_flash(dev_id, flash);
         }
-        raw::c_catch_asserts = if catch_asserts { 1 } else { 0 };
-        raw::c_asserts = 0u8;
-        raw::flash_counter = match counter {
+    }
+    let mut sim_ctx = api::CSimContext {
+        flash_counter: match counter {
             None => 0,
             Some(ref c) => **c as libc::c_int
-        };
-    }
-    let result = unsafe { raw::invoke_boot_go(&areadesc.get_c() as *const _) as i32 };
-    let asserts = unsafe { raw::c_asserts };
+        },
+        jumped: 0,
+        c_asserts: 0,
+        c_catch_asserts: if catch_asserts { 1 } else { 0 },
+        boot_jmpbuf: [0; 16],
+    };
+    let result = unsafe {
+        raw::invoke_boot_go(&mut sim_ctx as *mut _, &areadesc.get_c() as *const _) as i32
+    };
+    let asserts = sim_ctx.c_asserts;
+    counter.map(|c| *c = sim_ctx.flash_counter);
     unsafe {
-        counter.map(|c| *c = raw::flash_counter as i32);
         for (&dev_id, _) in multiflash {
             api::clear_flash(dev_id);
         }
@@ -76,16 +72,14 @@
 
 mod raw {
     use crate::area::CAreaDesc;
+    use crate::api::CSimContext;
     use libc;
 
     extern "C" {
         // This generates a warning about `CAreaDesc` not being foreign safe.  There doesn't appear to
         // be any way to get rid of this warning.  See https://github.com/rust-lang/rust/issues/34798
         // for information and tracking.
-        pub fn invoke_boot_go(areadesc: *const CAreaDesc) -> libc::c_int;
-        pub static mut flash_counter: libc::c_int;
-        pub static mut c_asserts: u8;
-        pub static mut c_catch_asserts: u8;
+        pub fn invoke_boot_go(sim_ctx: *mut CSimContext, areadesc: *const CAreaDesc) -> libc::c_int;
 
         pub fn boot_trailer_sz(min_write_sz: u8) -> u32;