src/v8/test/cctest/test-thread-termination.cc

   1 // Copyright 2009 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "src/v8.h"
  29 #include "test/cctest/cctest.h"
  30
  31 #include "src/base/platform/platform.h"
  32
  33
  34 v8::base::Semaphore* semaphore = NULL;
  35
  36
  37 void Signal(const v8::FunctionCallbackInfo<v8::Value>& args) {
  38   semaphore->Signal();
  39 }
  40
  41
  42 void TerminateCurrentThread(const v8::FunctionCallbackInfo<v8::Value>& args) {
  43   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
  44   v8::V8::TerminateExecution(args.GetIsolate());
  45 }
  46
  47
  48 void Fail(const v8::FunctionCallbackInfo<v8::Value>& args) {
  49   CHECK(false);
  50 }
  51
  52
  53 void Loop(const v8::FunctionCallbackInfo<v8::Value>& args) {
  54   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
  55   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
  56       args.GetIsolate(), "try { doloop(); fail(); } catch(e) { fail(); }");
  57   v8::Handle<v8::Value> result = v8::Script::Compile(source)->Run();
  58   CHECK(result.IsEmpty());
  59   CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
  60 }
  61
  62
  63 void DoLoop(const v8::FunctionCallbackInfo<v8::Value>& args) {
  64   v8::TryCatch try_catch;
  65   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
  66   v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
  67                                               "function f() {"
  68                                               "  var term = true;"
  69                                               "  try {"
  70                                               "    while(true) {"
  71                                               "      if (term) terminate();"
  72                                               "      term = false;"
  73                                               "    }"
  74                                               "    fail();"
  75                                               "  } catch(e) {"
  76                                               "    fail();"
  77                                               "  }"
  78                                               "}"
  79                                               "f()"))->Run();
  80   CHECK(try_catch.HasCaught());
  81   CHECK(try_catch.Exception()->IsNull());
  82   CHECK(try_catch.Message().IsEmpty());
  83   CHECK(!try_catch.CanContinue());
  84   CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
  85 }
  86
  87
  88 void DoLoopNoCall(const v8::FunctionCallbackInfo<v8::Value>& args) {
  89   v8::TryCatch try_catch;
  90   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
  91   v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
  92                                               "var term = true;"
  93                                               "while(true) {"
  94                                               "  if (term) terminate();"
  95                                               "  term = false;"
  96                                               "}"))->Run();
  97   CHECK(try_catch.HasCaught());
  98   CHECK(try_catch.Exception()->IsNull());
  99   CHECK(try_catch.Message().IsEmpty());
 100   CHECK(!try_catch.CanContinue());
 101   CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
 102 }
 103
 104
 105 v8::Handle<v8::ObjectTemplate> CreateGlobalTemplate(
 106     v8::Isolate* isolate,
 107     v8::FunctionCallback terminate,
 108     v8::FunctionCallback doloop) {
 109   v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
 110   global->Set(v8::String::NewFromUtf8(isolate, "terminate"),
 111               v8::FunctionTemplate::New(isolate, terminate));
 112   global->Set(v8::String::NewFromUtf8(isolate, "fail"),
 113               v8::FunctionTemplate::New(isolate, Fail));
 114   global->Set(v8::String::NewFromUtf8(isolate, "loop"),
 115               v8::FunctionTemplate::New(isolate, Loop));
 116   global->Set(v8::String::NewFromUtf8(isolate, "doloop"),
 117               v8::FunctionTemplate::New(isolate, doloop));
 118   return global;
 119 }
 120
 121
 122 // Test that a single thread of JavaScript execution can terminate
 123 // itself.
 124 TEST(TerminateOnlyV8ThreadFromThreadItself) {
 125   v8::HandleScope scope(CcTest::isolate());
 126   v8::Handle<v8::ObjectTemplate> global =
 127       CreateGlobalTemplate(CcTest::isolate(), TerminateCurrentThread, DoLoop);
 128   v8::Handle<v8::Context> context =
 129       v8::Context::New(CcTest::isolate(), NULL, global);
 130   v8::Context::Scope context_scope(context);
 131   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 132   // Run a loop that will be infinite if thread termination does not work.
 133   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 134       CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
 135   v8::Script::Compile(source)->Run();
 136   // Test that we can run the code again after thread termination.
 137   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 138   v8::Script::Compile(source)->Run();
 139 }
 140
 141
 142 // Test that a single thread of JavaScript execution can terminate
 143 // itself in a loop that performs no calls.
 144 TEST(TerminateOnlyV8ThreadFromThreadItselfNoLoop) {
 145   v8::HandleScope scope(CcTest::isolate());
 146   v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
 147       CcTest::isolate(), TerminateCurrentThread, DoLoopNoCall);
 148   v8::Handle<v8::Context> context =
 149       v8::Context::New(CcTest::isolate(), NULL, global);
 150   v8::Context::Scope context_scope(context);
 151   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 152   // Run a loop that will be infinite if thread termination does not work.
 153   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 154       CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
 155   v8::Script::Compile(source)->Run();
 156   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 157   // Test that we can run the code again after thread termination.
 158   v8::Script::Compile(source)->Run();
 159 }
 160
 161
 162 class TerminatorThread : public v8::base::Thread {
 163  public:
 164   explicit TerminatorThread(i::Isolate* isolate)
 165       : Thread(Options("TerminatorThread")),
 166         isolate_(reinterpret_cast<v8::Isolate*>(isolate)) {}
 167   void Run() {
 168     semaphore->Wait();
 169     CHECK(!v8::V8::IsExecutionTerminating(isolate_));
 170     v8::V8::TerminateExecution(isolate_);
 171   }
 172
 173  private:
 174   v8::Isolate* isolate_;
 175 };
 176
 177
 178 // Test that a single thread of JavaScript execution can be terminated
 179 // from the side by another thread.
 180 TEST(TerminateOnlyV8ThreadFromOtherThread) {
 181   semaphore = new v8::base::Semaphore(0);
 182   TerminatorThread thread(CcTest::i_isolate());
 183   thread.Start();
 184
 185   v8::HandleScope scope(CcTest::isolate());
 186   v8::Handle<v8::ObjectTemplate> global =
 187       CreateGlobalTemplate(CcTest::isolate(), Signal, DoLoop);
 188   v8::Handle<v8::Context> context =
 189       v8::Context::New(CcTest::isolate(), NULL, global);
 190   v8::Context::Scope context_scope(context);
 191   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 192   // Run a loop that will be infinite if thread termination does not work.
 193   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 194       CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
 195   v8::Script::Compile(source)->Run();
 196
 197   thread.Join();
 198   delete semaphore;
 199   semaphore = NULL;
 200 }
 201
 202
 203 int call_count = 0;
 204
 205
 206 void TerminateOrReturnObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
 207   if (++call_count == 10) {
 208     CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
 209     v8::V8::TerminateExecution(args.GetIsolate());
 210     return;
 211   }
 212   v8::Local<v8::Object> result = v8::Object::New(args.GetIsolate());
 213   result->Set(v8::String::NewFromUtf8(args.GetIsolate(), "x"),
 214               v8::Integer::New(args.GetIsolate(), 42));
 215   args.GetReturnValue().Set(result);
 216 }
 217
 218
 219 void LoopGetProperty(const v8::FunctionCallbackInfo<v8::Value>& args) {
 220   v8::TryCatch try_catch;
 221   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
 222   v8::Script::Compile(
 223       v8::String::NewFromUtf8(args.GetIsolate(),
 224                               "function f() {"
 225                               "  try {"
 226                               "    while(true) {"
 227                               "      terminate_or_return_object().x;"
 228                               "    }"
 229                               "    fail();"
 230                               "  } catch(e) {"
 231                               "    fail();"
 232                               "  }"
 233                               "}"
 234                               "f()"))->Run();
 235   CHECK(try_catch.HasCaught());
 236   CHECK(try_catch.Exception()->IsNull());
 237   CHECK(try_catch.Message().IsEmpty());
 238   CHECK(!try_catch.CanContinue());
 239   CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
 240 }
 241
 242
 243 // Test that we correctly handle termination exceptions if they are
 244 // triggered by the creation of error objects in connection with ICs.
 245 TEST(TerminateLoadICException) {
 246   v8::Isolate* isolate = CcTest::isolate();
 247   v8::HandleScope scope(isolate);
 248   v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
 249   global->Set(
 250       v8::String::NewFromUtf8(isolate, "terminate_or_return_object"),
 251       v8::FunctionTemplate::New(isolate, TerminateOrReturnObject));
 252   global->Set(v8::String::NewFromUtf8(isolate, "fail"),
 253               v8::FunctionTemplate::New(isolate, Fail));
 254   global->Set(v8::String::NewFromUtf8(isolate, "loop"),
 255               v8::FunctionTemplate::New(isolate, LoopGetProperty));
 256
 257   v8::Handle<v8::Context> context =
 258       v8::Context::New(isolate, NULL, global);
 259   v8::Context::Scope context_scope(context);
 260   CHECK(!v8::V8::IsExecutionTerminating(isolate));
 261   // Run a loop that will be infinite if thread termination does not work.
 262   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 263       isolate, "try { loop(); fail(); } catch(e) { fail(); }");
 264   call_count = 0;
 265   v8::Script::Compile(source)->Run();
 266   // Test that we can run the code again after thread termination.
 267   CHECK(!v8::V8::IsExecutionTerminating(isolate));
 268   call_count = 0;
 269   v8::Script::Compile(source)->Run();
 270 }
 271
 272
 273 void ReenterAfterTermination(const v8::FunctionCallbackInfo<v8::Value>& args) {
 274   v8::TryCatch try_catch;
 275   CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
 276   v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
 277                                               "function f() {"
 278                                               "  var term = true;"
 279                                               "  try {"
 280                                               "    while(true) {"
 281                                               "      if (term) terminate();"
 282                                               "      term = false;"
 283                                               "    }"
 284                                               "    fail();"
 285                                               "  } catch(e) {"
 286                                               "    fail();"
 287                                               "  }"
 288                                               "}"
 289                                               "f()"))->Run();
 290   CHECK(try_catch.HasCaught());
 291   CHECK(try_catch.Exception()->IsNull());
 292   CHECK(try_catch.Message().IsEmpty());
 293   CHECK(!try_catch.CanContinue());
 294   CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
 295   v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
 296                                               "function f() { fail(); } f()"))
 297       ->Run();
 298 }
 299
 300
 301 // Test that reentry into V8 while the termination exception is still pending
 302 // (has not yet unwound the 0-level JS frame) does not crash.
 303 TEST(TerminateAndReenterFromThreadItself) {
 304   v8::Isolate* isolate = CcTest::isolate();
 305   v8::HandleScope scope(isolate);
 306   v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
 307       isolate, TerminateCurrentThread, ReenterAfterTermination);
 308   v8::Handle<v8::Context> context =
 309       v8::Context::New(isolate, NULL, global);
 310   v8::Context::Scope context_scope(context);
 311   CHECK(!v8::V8::IsExecutionTerminating());
 312   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 313       isolate, "try { loop(); fail(); } catch(e) { fail(); }");
 314   v8::Script::Compile(source)->Run();
 315   CHECK(!v8::V8::IsExecutionTerminating(isolate));
 316   // Check we can run JS again after termination.
 317   CHECK(v8::Script::Compile(
 318       v8::String::NewFromUtf8(isolate,
 319                               "function f() { return true; }"
 320                               "f()"))
 321             ->Run()
 322             ->IsTrue());
 323 }
 324
 325
 326 void DoLoopCancelTerminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
 327   v8::TryCatch try_catch;
 328   CHECK(!v8::V8::IsExecutionTerminating());
 329   v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
 330                                               "var term = true;"
 331                                               "while(true) {"
 332                                               "  if (term) terminate();"
 333                                               "  term = false;"
 334                                               "}"
 335                                               "fail();"))->Run();
 336   CHECK(try_catch.HasCaught());
 337   CHECK(try_catch.Exception()->IsNull());
 338   CHECK(try_catch.Message().IsEmpty());
 339   CHECK(!try_catch.CanContinue());
 340   CHECK(v8::V8::IsExecutionTerminating());
 341   CHECK(try_catch.HasTerminated());
 342   v8::V8::CancelTerminateExecution(CcTest::isolate());
 343   CHECK(!v8::V8::IsExecutionTerminating());
 344 }
 345
 346
 347 // Test that a single thread of JavaScript execution can terminate
 348 // itself and then resume execution.
 349 TEST(TerminateCancelTerminateFromThreadItself) {
 350   v8::Isolate* isolate = CcTest::isolate();
 351   v8::HandleScope scope(isolate);
 352   v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
 353       isolate, TerminateCurrentThread, DoLoopCancelTerminate);
 354   v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
 355   v8::Context::Scope context_scope(context);
 356   CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
 357   v8::Handle<v8::String> source = v8::String::NewFromUtf8(
 358       isolate, "try { doloop(); } catch(e) { fail(); } 'completed';");
 359   // Check that execution completed with correct return value.
 360   CHECK(v8::Script::Compile(source)->Run()->Equals(v8_str("completed")));
 361 }
 362
 363
 364 void MicrotaskShouldNotRun(const v8::FunctionCallbackInfo<v8::Value>& info) {
 365   CHECK(false);
 366 }
 367
 368
 369 void MicrotaskLoopForever(const v8::FunctionCallbackInfo<v8::Value>& info) {
 370   v8::Isolate* isolate = info.GetIsolate();
 371   v8::HandleScope scope(isolate);
 372   // Enqueue another should-not-run task to ensure we clean out the queue
 373   // when we terminate.
 374   isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskShouldNotRun));
 375   CompileRun("terminate(); while (true) { }");
 376   CHECK(v8::V8::IsExecutionTerminating());
 377 }
 378
 379
 380 TEST(TerminateFromOtherThreadWhileMicrotaskRunning) {
 381   semaphore = new v8::base::Semaphore(0);
 382   TerminatorThread thread(CcTest::i_isolate());
 383   thread.Start();
 384
 385   v8::Isolate* isolate = CcTest::isolate();
 386   isolate->SetAutorunMicrotasks(false);
 387   v8::HandleScope scope(isolate);
 388   v8::Handle<v8::ObjectTemplate> global =
 389       CreateGlobalTemplate(CcTest::isolate(), Signal, DoLoop);
 390   v8::Handle<v8::Context> context =
 391       v8::Context::New(CcTest::isolate(), NULL, global);
 392   v8::Context::Scope context_scope(context);
 393   isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskLoopForever));
 394   // The second task should never be run because we bail out if we're
 395   // terminating.
 396   isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskShouldNotRun));
 397   isolate->RunMicrotasks();
 398
 399   v8::V8::CancelTerminateExecution(isolate);
 400   isolate->RunMicrotasks();  // should not run MicrotaskShouldNotRun
 401
 402   thread.Join();
 403   delete semaphore;
 404   semaphore = NULL;
 405 }
 406
 407
 408 static int callback_counter = 0;
 409
 410
 411 static void CounterCallback(v8::Isolate* isolate, void* data) {
 412   callback_counter++;
 413 }
 414
 415
 416 TEST(PostponeTerminateException) {
 417   v8::Isolate* isolate = CcTest::isolate();
 418   v8::HandleScope scope(isolate);
 419   v8::Handle<v8::ObjectTemplate> global =
 420       CreateGlobalTemplate(CcTest::isolate(), TerminateCurrentThread, DoLoop);
 421   v8::Handle<v8::Context> context =
 422       v8::Context::New(CcTest::isolate(), NULL, global);
 423   v8::Context::Scope context_scope(context);
 424
 425   v8::TryCatch try_catch;
 426   static const char* terminate_and_loop =
 427       "terminate(); for (var i = 0; i < 10000; i++);";
 428
 429   { // Postpone terminate execution interrupts.
 430     i::PostponeInterruptsScope p1(CcTest::i_isolate(),
 431                                   i::StackGuard::TERMINATE_EXECUTION) ;
 432
 433     // API interrupts should still be triggered.
 434     CcTest::isolate()->RequestInterrupt(&CounterCallback, NULL);
 435     CHECK_EQ(0, callback_counter);
 436     CompileRun(terminate_and_loop);
 437     CHECK(!try_catch.HasTerminated());
 438     CHECK_EQ(1, callback_counter);
 439
 440     { // Postpone API interrupts as well.
 441       i::PostponeInterruptsScope p2(CcTest::i_isolate(),
 442                                     i::StackGuard::API_INTERRUPT);
 443
 444       // None of the two interrupts should trigger.
 445       CcTest::isolate()->RequestInterrupt(&CounterCallback, NULL);
 446       CompileRun(terminate_and_loop);
 447       CHECK(!try_catch.HasTerminated());
 448       CHECK_EQ(1, callback_counter);
 449     }
 450
 451     // Now the previously requested API interrupt should trigger.
 452     CompileRun(terminate_and_loop);
 453     CHECK(!try_catch.HasTerminated());
 454     CHECK_EQ(2, callback_counter);
 455   }
 456
 457   // Now the previously requested terminate execution interrupt should trigger.
 458   CompileRun("for (var i = 0; i < 10000; i++);");
 459   CHECK(try_catch.HasTerminated());
 460   CHECK_EQ(2, callback_counter);
 461 }
 462
 463
 464 TEST(ErrorObjectAfterTermination) {
 465   v8::Isolate* isolate = CcTest::isolate();
 466   v8::HandleScope scope(isolate);
 467   v8::Handle<v8::Context> context = v8::Context::New(CcTest::isolate());
 468   v8::Context::Scope context_scope(context);
 469   v8::V8::TerminateExecution(isolate);
 470   v8::Local<v8::Value> error = v8::Exception::Error(v8_str("error"));
 471   // TODO(yangguo): crbug/403509. Check for empty handle instead.
 472   CHECK(error->IsUndefined());
 473 }