diff --git a/db/curop.h b/db/curop.h
index eac982a46cb..c21478c1608 100644
--- a/db/curop.h
+++ b/db/curop.h
@@ -24,6 +24,7 @@
 #include "../util/concurrency/spin_lock.h"
 #include "../util/time_support.h"
 #include "db.h"
+#include "../scripting/engine.h"
 
 namespace mongo { 
 
@@ -348,15 +349,26 @@ namespace mongo {
         enum { Off, On, All } state;
         AtomicUInt toKill;
     public:
-        void killAll() { state = All; }
-        void kill(AtomicUInt i) { toKill = i; state = On; }
+        // the kill functions are not called with a mutex
+        void killAll() { state = All; interruptJs( 0 ); }
+        void kill(AtomicUInt i) { toKill = i; state = On; interruptJs( &i ); }
+        
+        // this is called without a mutex also, which means we can miss some
+        // kill requests; it's no worse than what the code was doing before,
+        // though, so I don't feel too bad about adding this function.
+        // hopefully we will have time for SERVER-1816 to fix this
+        void finishOp() {
+            if( state == On && cc().curop()->opNum() == toKill ) { 
+                state = Off;
+            }
+        }
         
         void checkForInterrupt() { 
             if( state != Off ) { 
-                if( state == All ) 
+                if( state == All ) {
                     uasserted(11600,"interrupted at shutdown");
+                }
                 if( cc().curop()->opNum() == toKill ) { 
-                    state = Off;
                     uasserted(11601,"interrupted");
                 }
             }
@@ -367,11 +379,21 @@ namespace mongo {
                 if( state == All ) 
                     return "interrupted at shutdown";
                 if( cc().curop()->opNum() == toKill ) { 
-                    state = Off;
                     return "interrupted";
                 }
             }
             return "";
         }
+        
+        void interruptJs( AtomicUInt *op ) {
+            if ( !globalScriptEngine ) {
+                return;
+            }
+            if ( !op ) {
+                globalScriptEngine->interruptAll();
+            } else {
+                globalScriptEngine->interrupt( *op );
+            }
+        }
     } killCurrentOp;
 }
diff --git a/db/db.cpp b/db/db.cpp
index b03651ef5b9..51aaea84372 100644
--- a/db/db.cpp
+++ b/db/db.cpp
@@ -458,7 +458,7 @@ sendmore:
     }
     
     void flushDiagLog();
-
+    
     /**
      * does background async flushes of mmapped files
      */
@@ -505,6 +505,10 @@ sendmore:
         return killCurrentOp.checkForInterruptNoAssert();
     }
     
+    unsigned jsGetInterruptSpecCallback() {
+        return cc().curop()->opNum();
+    }
+    
     void _initAndListen(int listenPort, const char *appserverLoc = NULL) {
 
         bool is32bit = sizeof(int*) == 4;
@@ -563,6 +567,7 @@ sendmore:
         if ( useJNI ) {
             ScriptEngine::setup();
             globalScriptEngine->setCheckInterruptCallback( jsInterruptCallback );
+            globalScriptEngine->setGetInterruptSpecCallback( jsGetInterruptSpecCallback );
         }
 
         repairDatabases();
diff --git a/db/instance.cpp b/db/instance.cpp
index 1031c7f0c7b..ee2db5b151b 100644
--- a/db/instance.cpp
+++ b/db/instance.cpp
@@ -340,6 +340,7 @@ namespace mongo {
         }
         currentOp.ensureStarted();
         currentOp.done();
+        killCurrentOp.finishOp();
         int ms = currentOp.totalTimeMillis();
         
         log = log || (logLevel >= 2 && ++ctr % 512 == 0);
diff --git a/jstests/evalc.js b/jstests/evalc.js
index 59c94677d47..8a9e889c6ef 100644
--- a/jstests/evalc.js
+++ b/jstests/evalc.js
@@ -7,20 +7,6 @@ for( i = 0; i < 10; ++i ) {
 
 // SERVER-1610
 
-function op() {
-    uri = db.runCommand( "whatsmyuri" ).you;
-    printjson( uri );
-    p = db.currentOp().inprog;
-    for ( var i in p ) {
-        var o = p[ i ];
-        if ( o.client == uri ) {
-            print( "found it" );
-            return o.opid;
-        }
-    }
-    return -1;
-}
-
 s = startParallelShell( "print( 'starting forked:' + Date() ); for ( i=0; i<500000; i++ ){ db.currentOp(); } print( 'ending forked:' + Date() ); " )
 
 print( "starting eval: " + Date() )
diff --git a/jstests/evald.js b/jstests/evald.js
index dd92357404c..8a76292cf1f 100644
--- a/jstests/evald.js
+++ b/jstests/evald.js
@@ -1,11 +1,8 @@
 t = db.jstests_evald;
 t.drop();
 
-// only run in spidermonkey, not in v8 - see SERVER-387
-if ( typeof _threadInject == "undefined" ){
-
 function debug( x ) {
-//    print( x );
+//    printjson( x );
 }
 
 for( i = 0; i < 10; ++i ) {
@@ -13,30 +10,62 @@ for( i = 0; i < 10; ++i ) {
 }
 db.getLastError();
 
-ev = "while( 1 ) { db.jstests_evald.count( {i:10} ); }"
-
-function op() {
+function op( ev, where ) {
     p = db.currentOp().inprog;
+    debug( p );
     for ( var i in p ) {
         var o = p[ i ];
-        if ( o.active && o.query && o.query.$eval && o.query.$eval == ev ) {
-            return o.opid;
+        if ( where ) {
+            if ( o.active && o.query && o.query.query && o.query.query.$where && o.ns == "test.jstests_evald" ) {
+                return o.opid;
+            }
+        } else {
+            if ( o.active && o.query && o.query.$eval && o.query.$eval == ev ) {
+                return o.opid;
+            }
         }
     }
     return -1;
 }
 
-s = startParallelShell( "db.eval( '" + ev + "' )" );
+function doIt( ev, wait, where ) {
 
-o = null;
-assert.soon( function() { o = op(); return o != -1 } );
+    if ( where ) {
+        s = startParallelShell( ev );
+    } else {
+        s = startParallelShell( "db.eval( '" + ev + "' )" );        
+    }
 
-debug( "going to kill" );
+    o = null;
+    assert.soon( function() { o = op( ev, where ); return o != -1 } );
 
-db.killOp( o );
+    if ( wait ) {
+        sleep( 5000 );
+    }
 
-debug( "sent kill" );
+    debug( "going to kill" );
 
-s();
+    db.killOp( o );
 
-}
\ No newline at end of file
+    debug( "sent kill" );
+
+    s();
+
+}
+
+doIt( "db.jstests_evald.count( { $where: function() { while( 1 ) { ; } } } )", true, true );
+doIt( "db.jstests_evald.count( { $where: function() { while( 1 ) { ; } } } )", false, true );
+doIt( "while( true ) {;}", false );
+doIt( "while( true ) {;}", true );
+doIt( "while( 1 ) { db.jstests_evald.count( {i:10} ); }", true );
+doIt( "while( 1 ) { db.jstests_evald.count( {i:10} ); }", false );
+doIt( "while( 1 ) { db.jstests_evald.count(); }", true );
+doIt( "while( 1 ) { db.jstests_evald.count(); }", false );
+
+// these two are SERVER-1841
+//doIt( "while( 1 ) { try { db.jstests_evald.count( {i:10} ); } catch ( e ) { } }", true );
+//doIt( "while( 1 ) { try { while( 1 ) { ; } } catch ( e ) { } }", true );
+
+// the following won't work in v8 currently, see SERVER-1840
+//doIt( "while( 1 ) { db.jstests_evald.count( {$where:function(){ while( 1 ) {;}} } ); }", false );
+//doIt( "while( 1 ) { db.jstests_evald.count( {$where:function(){ while( 1 ) {;}} } ); }", true );
diff --git a/scripting/engine.cpp b/scripting/engine.cpp
index a75bf25fc7b..ae67b469029 100644
--- a/scripting/engine.cpp
+++ b/scripting/engine.cpp
@@ -444,8 +444,9 @@ namespace mongo {
     
     void ( *ScriptEngine::_connectCallback )( DBClientWithCommands & ) = 0;
     const char * ( *ScriptEngine::_checkInterruptCallback )() = 0;
+    unsigned ( *ScriptEngine::_getInterruptSpecCallback )() = 0;
     
-    ScriptEngine * globalScriptEngine;
+    ScriptEngine * globalScriptEngine = 0;
 
     bool hasJSReturn( const string& code ){
         size_t x = code.find( "return" );
diff --git a/scripting/engine.h b/scripting/engine.h
index b8265aa4b2e..e9ffd98caba 100644
--- a/scripting/engine.h
+++ b/scripting/engine.h
@@ -197,11 +197,30 @@ namespace mongo {
             if ( _connectCallback )
                 _connectCallback( c );
         }
+
+        // engine implementation may either respond to interrupt events or
+        // poll for interrupts
+        
+        // the interrupt functions must not wait indefinitely on a lock
+        virtual void interrupt( unsigned opSpec ) {}
+        virtual void interruptAll() {}
+        
+        static void setGetInterruptSpecCallback( unsigned ( *func )() ) { _getInterruptSpecCallback = func; }
+        static bool haveGetInterruptSpecCallback() { return _getInterruptSpecCallback; }
+        static unsigned getInterruptSpec() {
+            massert( 13474, "no _getInterruptSpecCallback", _getInterruptSpecCallback );
+            return _getInterruptSpecCallback();
+        }
+        
         static void setCheckInterruptCallback( const char * ( *func )() ) { _checkInterruptCallback = func; }
         static bool haveCheckInterruptCallback() { return _checkInterruptCallback; }
         static const char * checkInterrupt() {
             return _checkInterruptCallback ? _checkInterruptCallback() : "";
         }
+        static bool interrupted() {
+            const char *r = checkInterrupt();
+            return r && r[ 0 ];
+        }
         
     protected:
         virtual Scope * createScope() = 0;
@@ -210,6 +229,7 @@ namespace mongo {
         void ( *_scopeInitCallback )( Scope & );
         static void ( *_connectCallback )( DBClientWithCommands & );
         static const char * ( *_checkInterruptCallback )();
+        static unsigned ( *_getInterruptSpecCallback )();
     };
 
     bool hasJSReturn( const string& s );
diff --git a/scripting/engine_v8.cpp b/scripting/engine_v8.cpp
index 217ca7f4977..92312008af4 100644
--- a/scripting/engine_v8.cpp
+++ b/scripting/engine_v8.cpp
@@ -21,10 +21,13 @@
 #include "v8_utils.h"
 #include "v8_db.h"
 
-#define V8_SIMPLE_HEADER Locker l; HandleScope handle_scope; Context::Scope context_scope( _context );
+#define V8_SIMPLE_HEADER V8Lock l; HandleScope handle_scope; Context::Scope context_scope( _context );
 
 namespace mongo {
 
+    // guarded by v8 mutex
+    map< unsigned, int > __interruptSpecToThreadId;
+    
     // --- engine ---
 
     V8ScriptEngine::V8ScriptEngine() {}
@@ -37,6 +40,23 @@ namespace mongo {
             globalScriptEngine = new V8ScriptEngine();
         }
     }
+    
+    void V8ScriptEngine::interrupt( unsigned opSpec ) {
+        v8::Locker l;
+        if ( __interruptSpecToThreadId.count( opSpec ) ) {
+            V8::TerminateExecution( __interruptSpecToThreadId[ opSpec ] );
+        }
+    }
+    void V8ScriptEngine::interruptAll() {
+        v8::Locker l;
+        vector< int > toKill; // v8 mutex could potentially be yielded during the termination call
+        for( map< unsigned, int >::const_iterator i = __interruptSpecToThreadId.begin(); i != __interruptSpecToThreadId.end(); ++i ) {
+            toKill.push_back( i->second );
+        }
+        for( vector< int >::const_iterator i = toKill.begin(); i != toKill.end(); ++i ) {
+            V8::TerminateExecution( *i );            
+        }
+    }
 
     // --- scope ---
     
@@ -44,7 +64,7 @@ namespace mongo {
         : _engine( engine ) , 
           _connectState( NOT ){
 
-        Locker l;
+        V8Lock l;
         HandleScope handleScope;              
         _context = Context::New();
         Context::Scope context_scope( _context );
@@ -67,7 +87,7 @@ namespace mongo {
     }
 
     V8Scope::~V8Scope(){
-        Locker l;
+        V8Lock l;
         Context::Scope context_scope( _context );        
         _wrapper.Dispose();
         _this.Dispose();
@@ -79,7 +99,7 @@ namespace mongo {
     }
 
     Handle< Value > V8Scope::nativeCallback( const Arguments &args ) {
-        Locker l;
+        V8Lock l;
         HandleScope handle_scope;
         Local< External > f = External::Cast( *args.Callee()->Get( v8::String::New( "_native_function" ) ) );
         NativeFunction function = (NativeFunction)(f->Value());
@@ -102,7 +122,7 @@ namespace mongo {
     }
 
     Handle< Value > V8Scope::loadCallback( const Arguments &args ) {
-        Locker l;
+        V8Lock l;
         HandleScope handle_scope;
         Handle<External> field = Handle<External>::Cast(args.Data());
         void* ptr = field->Value();
@@ -121,7 +141,7 @@ namespace mongo {
     // ---- global stuff ----
 
     void V8Scope::init( BSONObj * data ){
-        Locker l;
+        V8Lock l;
         if ( ! data )
             return;
         
@@ -254,6 +274,7 @@ namespace mongo {
         code = fn + " = " + code;
 
         TryCatch try_catch;
+        // this might be time consuming, consider allowing an interrupt
         Handle<Script> script = v8::Script::Compile( v8::String::New( code.c_str() ) , 
                                                      v8::String::New( fn.c_str() ) );
         if ( script.IsEmpty() ){
@@ -323,11 +344,24 @@ namespace mongo {
         } else {
             _global->Set( v8::String::New( "args" ), v8::Undefined() );
         }
+        if ( globalScriptEngine->interrupted() ) {
+            stringstream ss;
+            ss << "error in invoke: " << globalScriptEngine->checkInterrupt();
+            _error = ss.str();
+            log() << _error << endl;
+            return 1;
+        }
+        enableV8Interrupt(); // because of v8 locker we can check interrupted, then enable
         Local<Value> result = ((v8::Function*)(*funcValue))->Call( _this , nargs , args.get() );
+        disableV8Interrupt();
                 
         if ( result.IsEmpty() ){
             stringstream ss;
-            ss << "error in invoke: " << toSTLString( &try_catch );
+            if ( try_catch.HasCaught() && !try_catch.CanContinue() ) {
+                ss << "error in invoke: " << globalScriptEngine->checkInterrupt();
+            } else {
+                ss << "error in invoke: " << toSTLString( &try_catch );
+            }
             _error = ss.str();
             log() << _error << endl;
             return 1;
@@ -366,9 +400,25 @@ namespace mongo {
             return false;
         } 
     
+        if ( globalScriptEngine->interrupted() ) {
+            _error = (string)"exec error: " + globalScriptEngine->checkInterrupt();
+            if ( reportError ) {
+                log() << _error << endl;
+            }
+            if ( assertOnError ) {
+                uassert( 13475 ,  _error , 0 );
+            }
+            return false;
+        }
+        enableV8Interrupt(); // because of v8 locker we can check interrupted, then enable
         Handle<v8::Value> result = script->Run();
+        disableV8Interrupt();
         if ( result.IsEmpty() ){
-            _error = (string)"exec error: " + toSTLString( &try_catch );
+            if ( try_catch.HasCaught() && !try_catch.CanContinue() ) {
+                _error = (string)"exec error: " + globalScriptEngine->checkInterrupt();
+            } else {
+                _error = (string)"exec error: " + toSTLString( &try_catch );
+            }
             if ( reportError )
                 log() << _error << endl;
             if ( assertOnError )
@@ -395,7 +445,7 @@ namespace mongo {
     
     void V8Scope::gc() {
         cout << "in gc" << endl;
-        Locker l;
+        V8Lock l;
         while( V8::IdleNotification() );
     }
 
@@ -413,6 +463,9 @@ namespace mongo {
                 throw UserException( 12511, "localConnect called with a different name previously" );
             }
 
+            // needed for killop / interrupt support
+            v8::Locker::StartPreemption( 50 );
+
             //_global->Set( v8::String::New( "Mongo" ) , _engine->_externalTemplate->GetFunction() );
             _global->Set( v8::String::New( "Mongo" ) , getMongoFunctionTemplate( true )->GetFunction() );
             execCoreFiles();
diff --git a/scripting/engine_v8.h b/scripting/engine_v8.h
index ca44f4843b8..82814a2f3a9 100644
--- a/scripting/engine_v8.h
+++ b/scripting/engine_v8.h
@@ -19,6 +19,7 @@
 
 #include <vector>
 #include "engine.h"
+#include "v8_db.h"
 #include <v8.h>
 
 using namespace v8;
@@ -103,16 +104,20 @@ namespace mongo {
 
         bool utf8Ok() const { return true; }
 
-        class V8Unlocker : public Unlocker {
-            v8::Unlocker u_;
+        class V8UnlockForClient : public Unlocker {
+            V8Unlock u_;
         };
         
-        virtual auto_ptr<Unlocker> newThreadUnlocker() { return auto_ptr< Unlocker >( new V8Unlocker ); }
+        virtual auto_ptr<Unlocker> newThreadUnlocker() { return auto_ptr< Unlocker >( new V8UnlockForClient ); }
         
+        virtual void interrupt( unsigned opSpec );
+        virtual void interruptAll();
+
     private:
         friend class V8Scope;
     };
     
     
     extern ScriptEngine * globalScriptEngine;
+    extern map< unsigned, int > __interruptSpecToThreadId;
 }
diff --git a/scripting/v8_db.cpp b/scripting/v8_db.cpp
index b425809fb1e..15ae8bacfd4 100644
--- a/scripting/v8_db.cpp
+++ b/scripting/v8_db.cpp
@@ -18,7 +18,7 @@
 #include "v8_wrapper.h"
 #include "v8_utils.h"
 #include "v8_db.h"
-#include "engine.h"
+#include "engine_v8.h"
 #include "util/base64.h"
 #include "util/text.h"
 #include "../client/syncclusterconnection.h"
@@ -166,7 +166,7 @@ namespace mongo {
         
         DBClientWithCommands * conn;
         {
-            Unlocker ul;
+            V8Unlock ul;
             conn = cs.connect( errmsg );
         }
         if ( ! conn )
@@ -176,7 +176,7 @@ namespace mongo {
         self.MakeWeak( conn , destroyConnection );
 
         {
-            Unlocker ul;
+            V8Unlock ul;
             ScriptEngine::runConnectCallback( *conn );
         }
 
@@ -194,7 +194,7 @@ namespace mongo {
 
         DBClientBase * conn;
         {
-            Unlocker ul;
+            V8Unlock ul;
             conn = createDirectClient();
         }
 
@@ -267,7 +267,7 @@ namespace mongo {
             int nToSkip = (int)(args[4]->ToNumber()->Value());
             int batchSize = (int)(args[5]->ToNumber()->Value());
             {
-                v8::Unlocker u;
+                V8Unlock u;
                 cursor = conn->query( ns, q ,  nToReturn , nToSkip , haveFields ? &fields : 0, slaveOk ? QueryOption_SlaveOk : 0 , batchSize );
             }
             v8::Function * cons = (v8::Function*)( *( mongo->Get( v8::String::New( "internalCursor" ) ) ) );
@@ -302,7 +302,7 @@ namespace mongo {
 
         DDD( "want to save : " << o.jsonString() );
         try {
-            v8::Unlocker u;
+            V8Unlock u;
             conn->insert( ns , o );
         }
         catch ( ... ){
@@ -329,7 +329,7 @@ namespace mongo {
 
         DDD( "want to remove : " << o.jsonString() );
         try {
-            v8::Unlocker u;
+            V8Unlock u;
             conn->remove( ns , o , justOne );
         }
         catch ( ... ){
@@ -356,7 +356,7 @@ namespace mongo {
         try {
             BSONObj q1 = v8ToMongo( q );
             BSONObj o1 = v8ToMongo( o );
-            v8::Unlocker u;
+            V8Unlock u;
             conn->update( ns , q1 , o1 , upsert, multi );
         }
         catch ( ... ){
@@ -388,7 +388,7 @@ namespace mongo {
             return v8::Undefined();
         BSONObj o;
         {
-            v8::Unlocker u;
+            V8Unlock u;
             o = cursor->next();
         }
         return mongoToV8( o );
@@ -400,7 +400,7 @@ namespace mongo {
             return Boolean::New( false );
         bool ret;
         {
-            v8::Unlocker u;
+            V8Unlock u;
             ret = cursor->more();
         }
         return Boolean::New( ret );
@@ -412,7 +412,7 @@ namespace mongo {
             return v8::Number::New( (double) 0 );
         int ret;
         {
-            v8::Unlocker u;
+            V8Unlock u;
             ret = cursor->objsLeftInBatch();
         }
         return v8::Number::New( (double) ret );
@@ -760,4 +760,51 @@ namespace mongo {
 
         return v8::Number::New( v8ToMongo( args[ 0 ]->ToObject() ).objsize() );
     }
+
+    // to be called with v8 mutex
+    void enableV8Interrupt() {
+        if ( globalScriptEngine->haveGetInterruptSpecCallback() ) {
+            __interruptSpecToThreadId[ globalScriptEngine->getInterruptSpec() ] = v8::V8::GetCurrentThreadId();
+        }
+    }
+    
+    // to be called with v8 mutex
+    void disableV8Interrupt() {
+        if ( globalScriptEngine->haveGetInterruptSpecCallback() ) {
+            __interruptSpecToThreadId.erase( globalScriptEngine->getInterruptSpec() );
+        }        
+    }
+
+    namespace v8Locks {
+        boost::mutex& __v8Mutex = *( new boost::mutex );
+        ThreadLocalValue< bool > __locked;
+
+        RecursiveLock::RecursiveLock() : _unlock() {
+            if ( !__locked.get() ) {
+                __v8Mutex.lock();
+                __locked.set( true );
+                _unlock = true;
+            }
+        }
+        RecursiveLock::~RecursiveLock() {
+            if ( _unlock ) {
+                __v8Mutex.unlock();
+                __locked.set( false );
+            }
+        }
+            
+        RecursiveUnlock::RecursiveUnlock() : _lock() {
+            if ( __locked.get() ) {
+                __v8Mutex.unlock();
+                __locked.set( false );
+                _lock = true;
+            }
+        }
+        RecursiveUnlock::~RecursiveUnlock() {
+            if ( _lock ) {
+                __v8Mutex.lock();
+                __locked.set( true );
+            }
+        }
+    } // namespace v8Locks
 }
diff --git a/scripting/v8_db.h b/scripting/v8_db.h
index 4211c1c7a38..a85255931c5 100644
--- a/scripting/v8_db.h
+++ b/scripting/v8_db.h
@@ -22,6 +22,7 @@
 #include <cstdio>
 #include <cstdlib>
 
+#include "engine.h"
 #include "../client/dbclient.h"
 
 namespace mongo {
@@ -75,20 +76,71 @@ namespace mongo {
 
     v8::Handle<v8::Value> bsonsize( const v8::Arguments& args );
 
-}
-
-template < v8::Handle< v8::Value > ( *f ) ( const v8::Arguments& ) >
-v8::Handle< v8::Value > v8Callback( const v8::Arguments &args ) {
-    try {
-        return f( args );
-    } catch( const std::exception &e ) {
-        return v8::ThrowException( v8::String::New( e.what() ) );
-    } catch( ... ) {
-        return v8::ThrowException( v8::String::New( "unknown exception" ) );
+    // call with v8 mutex:
+    void enableV8Interrupt();
+    void disableV8Interrupt();
+    
+    // The implementation below assumes that SERVER-1816 has been fixed - in
+    // particular, interrupted() must return true if an interrupt was ever
+    // sent; currently that is not the case if a new killop overwrites the data
+    // for an old one
+    template < v8::Handle< v8::Value > ( *f ) ( const v8::Arguments& ) >
+    v8::Handle< v8::Value > v8Callback( const v8::Arguments &args ) {
+        disableV8Interrupt(); // we don't want to have to audit all v8 calls for termination exceptions, so we don't allow these exceptions during the callback
+        if ( globalScriptEngine->interrupted() ) {
+            v8::V8::TerminateExecution(); // experimentally it seems that TerminateExecution() will override the return value
+            return v8::Undefined();
+        }
+        v8::Handle< v8::Value > ret;
+        string exception;
+        try {
+            ret = f( args );
+        } catch( const std::exception &e ) {
+            exception = e.what();
+        } catch( ... ) {
+            exception = "unknown exception";
+        }
+        enableV8Interrupt();
+        if ( globalScriptEngine->interrupted() ) {
+            v8::V8::TerminateExecution();
+            return v8::Undefined();
+        }
+        if ( !exception.empty() ) {
+            // technically, ThrowException is supposed to be the last v8 call before returning
+            ret = v8::ThrowException( v8::String::New( exception.c_str() ) );            
+        }
+        return ret;
     }
-}
-
-template < v8::Handle< v8::Value > ( *f ) ( const v8::Arguments& ) >
-v8::Local< v8::FunctionTemplate > newV8Function() {
-    return v8::FunctionTemplate::New( v8Callback< f > );
-}
+    
+    template < v8::Handle< v8::Value > ( *f ) ( const v8::Arguments& ) >
+    v8::Local< v8::FunctionTemplate > newV8Function() {
+        return v8::FunctionTemplate::New( v8Callback< f > );
+    }   
+    
+    // Preemption is going to be allowed for the v8 mutex, and some of our v8
+    // usage is not preemption safe.  So we are using an additional mutex that
+    // will not be preempted.  The V8Lock should be used in place of v8::Locker
+    // except in certain special cases involving interrupts.
+    namespace v8Locks {
+        // the implementations are quite simple - objects must be destroyed in
+        // reverse of the order created, and should not be shared between threads
+        struct RecursiveLock {
+            RecursiveLock();
+            ~RecursiveLock();
+            bool _unlock;
+        };
+        struct RecursiveUnlock {
+            RecursiveUnlock();
+            ~RecursiveUnlock();
+            bool _lock;
+        };
+    } // namespace v8Locks
+    class V8Lock {
+        v8Locks::RecursiveLock _noPreemptionLock;
+        v8::Locker _preemptionLock;
+    };
+    struct V8Unlock {
+        v8::Unlocker _preemptionUnlock;
+        v8Locks::RecursiveUnlock _noPreemptionUnlock;
+    };
+}
\ No newline at end of file
diff --git a/scripting/v8_utils.cpp b/scripting/v8_utils.cpp
index 85ac70c22fd..a7c82753b0c 100644
--- a/scripting/v8_utils.cpp
+++ b/scripting/v8_utils.cpp
@@ -171,7 +171,7 @@ namespace mongo {
         }
         void join() {
             jsassert( started_ && !done_, "Thread not running" );
-            Unlocker u;
+            V8Unlock u;
             thread_->join();
             done_ = true;
         }
@@ -185,7 +185,7 @@ namespace mongo {
         public:
             JSThread( JSThreadConfig &config ) : config_( config ) {}
             void operator()() {
-                Locker l;
+                V8Lock l;
                 HandleScope handle_scope;
                 Handle< Context > context;
                 Handle< v8::Function > fun;
@@ -304,7 +304,7 @@ namespace mongo {
     }
 
     Handle<v8::Value> GCV8(const Arguments& args) {
-        Locker l;
+        V8Lock l;
         while( V8::IdleNotification() );
         return v8::Undefined();
     }