1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "gin/array_buffer.h"
#include "build/build_config.h"
#include "gin/per_isolate_data.h"
#include "gin/public/isolate_holder.h"
#include "gin/test/v8_test.h"
#if defined(OS_POSIX)
#include <setjmp.h>
#include <signal.h>
#endif
namespace gin {
using ArrayBufferTest = V8Test;
namespace {
const size_t kBufferLength = 65536;
}
TEST_F(ArrayBufferTest, AllocateAndFreeBuffer) {
v8::Isolate* const isolate = instance_->isolate();
v8::ArrayBuffer::Allocator* const allocator =
PerIsolateData::From(isolate)->allocator();
void* buffer = allocator->Allocate(kBufferLength);
allocator->Free(buffer, kBufferLength);
}
TEST_F(ArrayBufferTest, ReserveAndReleaseBuffer) {
v8::Isolate* const isolate = instance_->isolate();
v8::ArrayBuffer::Allocator* const allocator =
PerIsolateData::From(isolate)->allocator();
void* buffer = allocator->Reserve(kBufferLength);
allocator->Free(buffer, kBufferLength,
v8::ArrayBuffer::Allocator::AllocationMode::kReservation);
}
TEST_F(ArrayBufferTest, SetProtectionReadWrite) {
v8::Isolate* const isolate = instance_->isolate();
v8::ArrayBuffer::Allocator* const allocator =
PerIsolateData::From(isolate)->allocator();
void* buffer = allocator->Reserve(kBufferLength);
allocator->SetProtection(buffer, kBufferLength,
v8::ArrayBuffer::Allocator::Protection::kReadWrite);
volatile int* int_buffer = static_cast<volatile int*>(buffer);
// Try assigning to the buffer. This will fault if we don't SetProtection
// first.
int_buffer[0] = 42;
allocator->Free(buffer, kBufferLength,
v8::ArrayBuffer::Allocator::AllocationMode::kReservation);
}
#if defined(OS_POSIX)
namespace {
sigjmp_buf g_continuation_;
void SignalHandler(int signal, siginfo_t* info, void*) {
siglongjmp(g_continuation_, 1);
}
} // namespace
TEST_F(ArrayBufferTest, ReservationReadOnlyByDefault) {
v8::Isolate* const isolate = instance_->isolate();
v8::ArrayBuffer::Allocator* const allocator =
PerIsolateData::From(isolate)->allocator();
void* buffer = allocator->Reserve(kBufferLength);
volatile int* int_buffer = static_cast<volatile int*>(buffer);
// Install a signal handler so we can catch the fault we're about to trigger.
struct sigaction action = {};
struct sigaction old_action = {};
action.sa_sigaction = SignalHandler;
sigemptyset(&action.sa_mask);
action.sa_flags = SA_SIGINFO;
sigaction(SIGSEGV, &action, &old_action);
#if defined(OS_MACOSX)
// On Mac, sometimes we get SIGBUS instead of SIGSEGV.
struct sigaction old_bus_action;
sigaction(SIGBUS, &action, &old_bus_action);
#endif
int const save_sigs = 1;
if (!sigsetjmp(g_continuation_, save_sigs)) {
// Try assigning to the buffer. This will fault if we don't SetProtection
// first.
int_buffer[0] = 42;
} else {
// if sigsetjmp returns nonzero, then we are returning from our handler.
sigaction(SIGSEGV, &old_action, nullptr);
#if defined(OS_MACOSX)
sigaction(SIGBUS, &old_bus_action, nullptr);
#endif
allocator->Free(buffer, kBufferLength,
v8::ArrayBuffer::Allocator::AllocationMode::kReservation);
SUCCEED();
return;
}
FAIL();
}
#endif // OS_POSIX
} // namespace gin
|
