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
Signal(const v8::FunctionCallbackInfo<v8::Value> & args)37 void Signal(const v8::FunctionCallbackInfo<v8::Value>& args) {
38 semaphore->Signal();
39 }
40
41
TerminateCurrentThread(const v8::FunctionCallbackInfo<v8::Value> & args)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
Fail(const v8::FunctionCallbackInfo<v8::Value> & args)48 void Fail(const v8::FunctionCallbackInfo<v8::Value>& args) {
49 CHECK(false);
50 }
51
52
Loop(const v8::FunctionCallbackInfo<v8::Value> & args)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
DoLoop(const v8::FunctionCallbackInfo<v8::Value> & args)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
DoLoopNoCall(const v8::FunctionCallbackInfo<v8::Value> & args)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
CreateGlobalTemplate(v8::Isolate * isolate,v8::FunctionCallback terminate,v8::FunctionCallback doloop)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.
TEST(TerminateOnlyV8ThreadFromThreadItself)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.
TEST(TerminateOnlyV8ThreadFromThreadItselfNoLoop)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:
TerminatorThread(i::Isolate * isolate)164 explicit TerminatorThread(i::Isolate* isolate)
165 : Thread(Options("TerminatorThread")),
166 isolate_(reinterpret_cast<v8::Isolate*>(isolate)) {}
Run()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.
TEST(TerminateOnlyV8ThreadFromOtherThread)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
TerminateOrReturnObject(const v8::FunctionCallbackInfo<v8::Value> & args)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
LoopGetProperty(const v8::FunctionCallbackInfo<v8::Value> & args)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.
TEST(TerminateLoadICException)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
ReenterAfterTermination(const v8::FunctionCallbackInfo<v8::Value> & args)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.
TEST(TerminateAndReenterFromThreadItself)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
DoLoopCancelTerminate(const v8::FunctionCallbackInfo<v8::Value> & args)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.
TEST(TerminateCancelTerminateFromThreadItself)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
MicrotaskShouldNotRun(const v8::FunctionCallbackInfo<v8::Value> & info)364 void MicrotaskShouldNotRun(const v8::FunctionCallbackInfo<v8::Value>& info) {
365 CHECK(false);
366 }
367
368
MicrotaskLoopForever(const v8::FunctionCallbackInfo<v8::Value> & info)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
TEST(TerminateFromOtherThreadWhileMicrotaskRunning)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
CounterCallback(v8::Isolate * isolate,void * data)411 static void CounterCallback(v8::Isolate* isolate, void* data) {
412 callback_counter++;
413 }
414
415
TEST(PostponeTerminateException)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
TEST(ErrorObjectAfterTermination)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 }
474