1 // Copyright 2014 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 // Platform specific code for AIX goes here. For the POSIX comaptible parts 6 // the implementation is in platform-posix.cc. 7 8 #include <pthread.h> 9 #include <semaphore.h> 10 #include <signal.h> 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <sys/resource.h> 14 #include <sys/time.h> 15 #include <sys/ucontext.h> 16 17 #include <errno.h> 18 #include <fcntl.h> // open 19 #include <limits.h> 20 #include <stdarg.h> 21 #include <strings.h> // index 22 #include <sys/mman.h> // mmap & munmap 23 #include <sys/stat.h> // open 24 #include <sys/types.h> // mmap & munmap 25 #include <unistd.h> // getpagesize 26 27 #include <cmath> 28 29 #undef MAP_TYPE 30 31 #include "src/base/macros.h" 32 #include "src/base/platform/platform.h" 33 34 35 namespace v8 { 36 namespace base { 37 38 39 static inline void* mmapHelper(size_t len, int prot, int flags, int fildes, 40 off_t off) { 41 void* addr = OS::GetRandomMmapAddr(); 42 return mmap(addr, len, prot, flags, fildes, off); 43 } 44 45 46 const char* OS::LocalTimezone(double time, TimezoneCache* cache) { 47 if (std::isnan(time)) return ""; 48 time_t tv = static_cast<time_t>(floor(time / msPerSecond)); 49 struct tm* t = localtime(&tv); // NOLINT(runtime/threadsafe_fn) 50 if (NULL == t) return ""; 51 return tzname[0]; // The location of the timezone string on AIX. 52 } 53 54 55 double OS::LocalTimeOffset(TimezoneCache* cache) { 56 // On AIX, struct tm does not contain a tm_gmtoff field. 57 time_t utc = time(NULL); 58 DCHECK(utc != -1); 59 struct tm* loc = localtime(&utc); // NOLINT(runtime/threadsafe_fn) 60 DCHECK(loc != NULL); 61 return static_cast<double>((mktime(loc) - utc) * msPerSecond); 62 } 63 64 65 void* OS::Allocate(const size_t requested, size_t* allocated, bool executable) { 66 const size_t msize = RoundUp(requested, getpagesize()); 67 int prot = PROT_READ | PROT_WRITE | (executable ? PROT_EXEC : 0); 68 void* mbase = mmapHelper(msize, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 69 70 if (mbase == MAP_FAILED) return NULL; 71 *allocated = msize; 72 return mbase; 73 } 74 75 76 static unsigned StringToLong(char* buffer) { 77 return static_cast<unsigned>(strtol(buffer, NULL, 16)); // NOLINT 78 } 79 80 81 std::vector<OS::SharedLibraryAddress> OS::GetSharedLibraryAddresses() { 82 std::vector<SharedLibraryAddress> result; 83 static const int MAP_LENGTH = 1024; 84 int fd = open("/proc/self/maps", O_RDONLY); 85 if (fd < 0) return result; 86 while (true) { 87 char addr_buffer[11]; 88 addr_buffer[0] = '0'; 89 addr_buffer[1] = 'x'; 90 addr_buffer[10] = 0; 91 ssize_t rc = read(fd, addr_buffer + 2, 8); 92 if (rc < 8) break; 93 unsigned start = StringToLong(addr_buffer); 94 rc = read(fd, addr_buffer + 2, 1); 95 if (rc < 1) break; 96 if (addr_buffer[2] != '-') break; 97 rc = read(fd, addr_buffer + 2, 8); 98 if (rc < 8) break; 99 unsigned end = StringToLong(addr_buffer); 100 char buffer[MAP_LENGTH]; 101 int bytes_read = -1; 102 do { 103 bytes_read++; 104 if (bytes_read >= MAP_LENGTH - 1) break; 105 rc = read(fd, buffer + bytes_read, 1); 106 if (rc < 1) break; 107 } while (buffer[bytes_read] != '\n'); 108 buffer[bytes_read] = 0; 109 // Ignore mappings that are not executable. 110 if (buffer[3] != 'x') continue; 111 char* start_of_path = index(buffer, '/'); 112 // There may be no filename in this line. Skip to next. 113 if (start_of_path == NULL) continue; 114 buffer[bytes_read] = 0; 115 result.push_back(SharedLibraryAddress(start_of_path, start, end)); 116 } 117 close(fd); 118 return result; 119 } 120 121 122 void OS::SignalCodeMovingGC() {} 123 124 125 // Constants used for mmap. 126 static const int kMmapFd = -1; 127 static const int kMmapFdOffset = 0; 128 129 VirtualMemory::VirtualMemory() : address_(NULL), size_(0) {} 130 131 132 VirtualMemory::VirtualMemory(size_t size) 133 : address_(ReserveRegion(size)), size_(size) {} 134 135 136 VirtualMemory::VirtualMemory(size_t size, size_t alignment) 137 : address_(NULL), size_(0) { 138 DCHECK((alignment % OS::AllocateAlignment()) == 0); 139 size_t request_size = 140 RoundUp(size + alignment, static_cast<intptr_t>(OS::AllocateAlignment())); 141 void* reservation = 142 mmapHelper(request_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, kMmapFd, 143 kMmapFdOffset); 144 if (reservation == MAP_FAILED) return; 145 146 uint8_t* base = static_cast<uint8_t*>(reservation); 147 uint8_t* aligned_base = RoundUp(base, alignment); 148 DCHECK_LE(base, aligned_base); 149 150 // Unmap extra memory reserved before and after the desired block. 151 if (aligned_base != base) { 152 size_t prefix_size = static_cast<size_t>(aligned_base - base); 153 OS::Free(base, prefix_size); 154 request_size -= prefix_size; 155 } 156 157 size_t aligned_size = RoundUp(size, OS::AllocateAlignment()); 158 DCHECK_LE(aligned_size, request_size); 159 160 if (aligned_size != request_size) { 161 size_t suffix_size = request_size - aligned_size; 162 OS::Free(aligned_base + aligned_size, suffix_size); 163 request_size -= suffix_size; 164 } 165 166 DCHECK(aligned_size == request_size); 167 168 address_ = static_cast<void*>(aligned_base); 169 size_ = aligned_size; 170 } 171 172 173 VirtualMemory::~VirtualMemory() { 174 if (IsReserved()) { 175 bool result = ReleaseRegion(address(), size()); 176 DCHECK(result); 177 USE(result); 178 } 179 } 180 181 182 bool VirtualMemory::IsReserved() { return address_ != NULL; } 183 184 185 void VirtualMemory::Reset() { 186 address_ = NULL; 187 size_ = 0; 188 } 189 190 191 bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) { 192 return CommitRegion(address, size, is_executable); 193 } 194 195 196 bool VirtualMemory::Uncommit(void* address, size_t size) { 197 return UncommitRegion(address, size); 198 } 199 200 201 bool VirtualMemory::Guard(void* address) { 202 OS::Guard(address, OS::CommitPageSize()); 203 return true; 204 } 205 206 207 void* VirtualMemory::ReserveRegion(size_t size) { 208 void* result = mmapHelper(size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 209 kMmapFd, kMmapFdOffset); 210 211 if (result == MAP_FAILED) return NULL; 212 213 return result; 214 } 215 216 217 bool VirtualMemory::CommitRegion(void* base, size_t size, bool is_executable) { 218 #if defined(__native_client__) 219 // The Native Client port of V8 uses an interpreter, 220 // so code pages don't need PROT_EXEC. 221 int prot = PROT_READ | PROT_WRITE; 222 #else 223 int prot = PROT_READ | PROT_WRITE | (is_executable ? PROT_EXEC : 0); 224 #endif 225 if (mprotect(base, size, prot) == -1) return false; 226 227 return true; 228 } 229 230 231 bool VirtualMemory::UncommitRegion(void* base, size_t size) { 232 return mprotect(base, size, PROT_NONE) != -1; 233 } 234 235 236 bool VirtualMemory::ReleaseRegion(void* base, size_t size) { 237 return munmap(base, size) == 0; 238 } 239 240 241 bool VirtualMemory::HasLazyCommits() { return true; } 242 } // namespace base 243 } // namespace v8 244
