| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2017 the V8 project authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // PLEASE READ BEFORE CHANGING THIS FILE! | |
| 6 // | |
| 7 // This file implements the support code for the out of bounds signal handler. | |
| 8 // Nothing in here actually runs in the signal handler, but the code here | |
| 9 // manipulates data structures used by the signal handler so we still need to be | |
| 10 // careful. In order to minimize this risk, here are some rules to follow. | |
| 11 // | |
| 12 // 1. Avoid introducing new external dependencies. The files in src/trap-handler | |
| 13 // should be as self-contained as possible to make it easy to audit the code. | |
| 14 // | |
| 15 // 2. Any changes must be reviewed by someone from the crash reporting | |
| 16 // or security team. Se OWNERS for suggested reviewers. | |
| 17 // | |
| 18 // For more information, see https://goo.gl/yMeyUY. | |
| 19 // | |
| 20 // For the code that runs in the signal handler itself, see handler-inside.cc. | |
| 21 | |
| 22 #include <signal.h> | |
| 23 #include <stddef.h> | |
| 24 #include <stdio.h> | |
| 25 #include <stdlib.h> | |
| 26 #include <string.h> | |
| 27 | |
| 28 #include <atomic> | |
| 29 #include <limits> | |
| 30 | |
| 31 #include "src/trap-handler/trap-handler-internal.h" | |
| 32 #include "src/trap-handler/trap-handler.h" | |
| 33 | |
| 34 namespace { | |
| 35 size_t gNextCodeObject = 0; | |
| 36 } | |
| 37 | |
| 38 namespace v8 { | |
| 39 namespace internal { | |
| 40 namespace trap_handler { | |
| 41 | |
| 42 const size_t kInitialCodeObjectSize = 1024; | |
| 43 const size_t kCodeObjectGrowthFactor = 2; | |
| 44 | |
| 45 constexpr size_t HandlerDataSize(size_t num_protected_instructions) { | |
| 46 return offsetof(CodeProtectionInfo, instructions) + | |
| 47 num_protected_instructions * sizeof(ProtectedInstructionData); | |
| 48 } | |
| 49 | |
| 50 CodeProtectionInfo* CreateHandlerData( | |
| 51 void* base, size_t size, size_t num_protected_instructions, | |
| 52 ProtectedInstructionData* protected_instructions) { | |
| 53 const size_t alloc_size = HandlerDataSize(num_protected_instructions); | |
| 54 CodeProtectionInfo* data = | |
| 55 reinterpret_cast<CodeProtectionInfo*>(malloc(alloc_size)); | |
| 56 | |
| 57 if (data == nullptr) { | |
| 58 return nullptr; | |
| 59 } | |
| 60 | |
| 61 data->base = base; | |
| 62 data->size = size; | |
| 63 data->num_protected_instructions = num_protected_instructions; | |
| 64 | |
| 65 memcpy(data->instructions, protected_instructions, | |
| 66 num_protected_instructions * sizeof(ProtectedInstructionData)); | |
| 67 | |
| 68 return data; | |
| 69 } | |
| 70 | |
| 71 void UpdateHandlerDataCodePointer(int index, void* base) { | |
| 72 MetadataLock lock; | |
| 73 if (static_cast<size_t>(index) >= gNumCodeObjects) { | |
| 74 abort(); | |
| 75 } | |
| 76 CodeProtectionInfo* data = gCodeObjects[index].code_info; | |
| 77 data->base = base; | |
| 78 } | |
| 79 | |
| 80 int RegisterHandlerData(void* base, size_t size, | |
| 81 size_t num_protected_instructions, | |
| 82 ProtectedInstructionData* protected_instructions) { | |
| 83 // TODO(eholk): in debug builds, make sure this data isn't already registered. | |
| 84 | |
| 85 CodeProtectionInfo* data = CreateHandlerData( | |
| 86 base, size, num_protected_instructions, protected_instructions); | |
| 87 | |
| 88 if (data == nullptr) { | |
| 89 abort(); | |
| 90 } | |
| 91 | |
| 92 MetadataLock lock; | |
| 93 | |
| 94 size_t i = gNextCodeObject; | |
| 95 | |
| 96 // Explicitly convert std::numeric_limits<int>::max() to unsigned to avoid | |
| 97 // compiler warnings about signed/unsigned comparisons. We aren't worried | |
| 98 // about sign extension because we know std::numeric_limits<int>::max() is | |
| 99 // positive. | |
| 100 const size_t int_max = std::numeric_limits<int>::max(); | |
| 101 | |
| 102 // We didn't find an opening in the available space, so grow. | |
| 103 if (i == gNumCodeObjects) { | |
| 104 size_t new_size = gNumCodeObjects > 0 | |
| 105 ? gNumCodeObjects * kCodeObjectGrowthFactor | |
| 106 : kInitialCodeObjectSize; | |
| 107 | |
| 108 // Because we must return an int, there is no point in allocating space for | |
| 109 // more objects than can fit in an int. | |
| 110 if (new_size > int_max) { | |
| 111 new_size = int_max; | |
| 112 } | |
| 113 if (new_size == gNumCodeObjects) { | |
| 114 return -1; | |
| 115 } | |
| 116 | |
| 117 // Now that we know our new size is valid, we can go ahead and realloc the | |
| 118 // array. | |
| 119 gCodeObjects = static_cast<CodeProtectionInfoListEntry*>( | |
| 120 realloc(gCodeObjects, sizeof(*gCodeObjects) * new_size)); | |
| 121 | |
| 122 if (gCodeObjects == nullptr) { | |
| 123 abort(); | |
| 124 } | |
| 125 | |
| 126 memset(gCodeObjects + gNumCodeObjects, 0, | |
| 127 sizeof(*gCodeObjects) * (new_size - gNumCodeObjects)); | |
| 128 gNumCodeObjects = new_size; | |
| 129 } | |
| 130 | |
| 131 DCHECK(gCodeObjects[i].code_info == nullptr); | |
| 132 | |
| 133 // Find out where the next entry should go. | |
| 134 if (gCodeObjects[i].next_free == 0) { | |
| 135 // if this is a fresh entry, use the next one. | |
| 136 gNextCodeObject = i + 1; | |
| 137 DCHECK(gNextCodeObject == gNumCodeObjects || | |
| 138 (gCodeObjects[gNextCodeObject].code_info == nullptr && | |
| 139 gCodeObjects[gNextCodeObject].next_free == 0)); | |
| 140 } else { | |
| 141 gNextCodeObject = gCodeObjects[i].next_free - 1; | |
| 142 } | |
| 143 | |
| 144 if (i <= int_max) { | |
| 145 gCodeObjects[i].code_info = data; | |
| 146 return static_cast<int>(i); | |
| 147 } else { | |
| 148 return -1; | |
| 149 } | |
| 150 } | |
| 151 | |
| 152 void ReleaseHandlerData(int index) { | |
| 153 // Remove the data from the global list if it's there. | |
| 154 CodeProtectionInfo* data = nullptr; | |
| 155 { | |
| 156 MetadataLock lock; | |
| 157 | |
| 158 data = gCodeObjects[index].code_info; | |
| 159 gCodeObjects[index].code_info = nullptr; | |
| 160 | |
| 161 // +1 because we reserve {next_entry == 0} to indicate a fresh list entry. | |
| 162 gCodeObjects[index].next_free = gNextCodeObject + 1; | |
| 163 gNextCodeObject = index; | |
| 164 } | |
| 165 // TODO(eholk): on debug builds, ensure there are no more copies in | |
| 166 // the list. | |
| 167 free(data); | |
| 168 } | |
| 169 | |
| 170 bool RegisterDefaultSignalHandler() { | |
| 171 #if V8_TRAP_HANDLER_SUPPORTED | |
| 172 struct sigaction action; | |
| 173 action.sa_sigaction = HandleSignal; | |
| 174 action.sa_flags = SA_SIGINFO; | |
| 175 sigemptyset(&action.sa_mask); | |
| 176 // {sigaction} installs a new custom segfault handler. On success, it returns | |
| 177 // 0. If we get a nonzero value, we report an error to the caller by returning | |
| 178 // false. | |
| 179 if (sigaction(SIGSEGV, &action, nullptr) != 0) { | |
| 180 return false; | |
| 181 } | |
| 182 | |
| 183 return true; | |
| 184 #else | |
| 185 return false; | |
| 186 #endif | |
| 187 } | |
| 188 | |
| 189 } // namespace trap_handler | |
| 190 } // namespace internal | |
| 191 } // namespace v8 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2744383002:
Revert of [wasm] Initial signal handler (Closed)
