src/v8/src/base/platform/platform-posix.cc

   1 // Copyright 2012 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 POSIX goes here. This is not a platform on its
   6 // own, but contains the parts which are the same across the POSIX platforms
   7 // Linux, MacOS, FreeBSD, OpenBSD, NetBSD and QNX.
   8
   9 #include <errno.h>
  10 #include <limits.h>
  11 #include <pthread.h>
  12 #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__OpenBSD__)
  13 #include <pthread_np.h>  // for pthread_set_name_np
  14 #endif
  15 #include <sched.h>  // for sched_yield
  16 #include <time.h>
  17 #include <unistd.h>
  18
  19 #include <sys/mman.h>
  20 #include <sys/resource.h>
  21 #include <sys/stat.h>
  22 #include <sys/time.h>
  23 #include <sys/types.h>
  24 #if defined(__APPLE__) || defined(__DragonFly__) || defined(__FreeBSD__) || \
  25     defined(__NetBSD__) || defined(__OpenBSD__)
  26 #include <sys/sysctl.h>  // NOLINT, for sysctl
  27 #endif
  28
  29 #undef MAP_TYPE
  30
  31 #if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
  32 #define LOG_TAG "v8"
  33 #include <android/log.h>  // NOLINT
  34 #endif
  35
  36 #include <cmath>
  37 #include <cstdlib>
  38
  39 #include "src/base/lazy-instance.h"
  40 #include "src/base/macros.h"
  41 #include "src/base/platform/platform.h"
  42 #include "src/base/platform/time.h"
  43 #include "src/base/utils/random-number-generator.h"
  44
  45 #ifdef V8_FAST_TLS_SUPPORTED
  46 #include "src/base/atomicops.h"
  47 #endif
  48
  49 #if V8_OS_MACOSX
  50 #include <dlfcn.h>
  51 #endif
  52
  53 #if V8_OS_LINUX
  54 #include <sys/prctl.h>  // NOLINT, for prctl
  55 #endif
  56
  57 #if !V8_OS_NACL
  58 #include <sys/syscall.h>
  59 #endif
  60
  61 namespace v8 {
  62 namespace base {
  63
  64 namespace {
  65
  66 // 0 is never a valid thread id.
  67 const pthread_t kNoThread = (pthread_t) 0;
  68
  69 bool g_hard_abort = false;
  70
  71 const char* g_gc_fake_mmap = NULL;
  72
  73 }  // namespace
  74
  75
  76 int OS::ActivationFrameAlignment() {
  77 #if V8_TARGET_ARCH_ARM
  78   // On EABI ARM targets this is required for fp correctness in the
  79   // runtime system.
  80   return 8;
  81 #elif V8_TARGET_ARCH_MIPS
  82   return 8;
  83 #else
  84   // Otherwise we just assume 16 byte alignment, i.e.:
  85   // - With gcc 4.4 the tree vectorization optimizer can generate code
  86   //   that requires 16 byte alignment such as movdqa on x86.
  87   // - Mac OS X and Solaris (64-bit) activation frames must be 16 byte-aligned;
  88   //   see "Mac OS X ABI Function Call Guide"
  89   return 16;
  90 #endif
  91 }
  92
  93
  94 intptr_t OS::CommitPageSize() {
  95   static intptr_t page_size = getpagesize();
  96   return page_size;
  97 }
  98
  99
 100 void OS::Free(void* address, const size_t size) {
 101   // TODO(1240712): munmap has a return value which is ignored here.
 102   int result = munmap(address, size);
 103   USE(result);
 104   DCHECK(result == 0);
 105 }
 106
 107
 108 // Get rid of writable permission on code allocations.
 109 void OS::ProtectCode(void* address, const size_t size) {
 110 #if V8_OS_CYGWIN
 111   DWORD old_protect;
 112   VirtualProtect(address, size, PAGE_EXECUTE_READ, &old_protect);
 113 #elif V8_OS_NACL
 114   // The Native Client port of V8 uses an interpreter, so
 115   // code pages don't need PROT_EXEC.
 116   mprotect(address, size, PROT_READ);
 117 #else
 118   mprotect(address, size, PROT_READ | PROT_EXEC);
 119 #endif
 120 }
 121
 122
 123 // Create guard pages.
 124 void OS::Guard(void* address, const size_t size) {
 125 #if V8_OS_CYGWIN
 126   DWORD oldprotect;
 127   VirtualProtect(address, size, PAGE_NOACCESS, &oldprotect);
 128 #else
 129   mprotect(address, size, PROT_NONE);
 130 #endif
 131 }
 132
 133
 134 static LazyInstance<RandomNumberGenerator>::type
 135     platform_random_number_generator = LAZY_INSTANCE_INITIALIZER;
 136
 137
 138 void OS::Initialize(int64_t random_seed, bool hard_abort,
 139                     const char* const gc_fake_mmap) {
 140   if (random_seed) {
 141     platform_random_number_generator.Pointer()->SetSeed(random_seed);
 142   }
 143   g_hard_abort = hard_abort;
 144   g_gc_fake_mmap = gc_fake_mmap;
 145 }
 146
 147
 148 const char* OS::GetGCFakeMMapFile() {
 149   return g_gc_fake_mmap;
 150 }
 151
 152
 153 void* OS::GetRandomMmapAddr() {
 154 #if V8_OS_NACL
 155   // TODO(bradchen): restore randomization once Native Client gets
 156   // smarter about using mmap address hints.
 157   // See http://code.google.com/p/nativeclient/issues/3341
 158   return NULL;
 159 #endif
 160 #if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
 161     defined(THREAD_SANITIZER)
 162   // Dynamic tools do not support custom mmap addresses.
 163   return NULL;
 164 #endif
 165   uintptr_t raw_addr;
 166   platform_random_number_generator.Pointer()->NextBytes(&raw_addr,
 167                                                         sizeof(raw_addr));
 168 #if V8_TARGET_ARCH_X64
 169   // Currently available CPUs have 48 bits of virtual addressing.  Truncate
 170   // the hint address to 46 bits to give the kernel a fighting chance of
 171   // fulfilling our placement request.
 172   raw_addr &= V8_UINT64_C(0x3ffffffff000);
 173 #else
 174   raw_addr &= 0x3ffff000;
 175
 176 # ifdef __sun
 177   // For our Solaris/illumos mmap hint, we pick a random address in the bottom
 178   // half of the top half of the address space (that is, the third quarter).
 179   // Because we do not MAP_FIXED, this will be treated only as a hint -- the
 180   // system will not fail to mmap() because something else happens to already
 181   // be mapped at our random address. We deliberately set the hint high enough
 182   // to get well above the system's break (that is, the heap); Solaris and
 183   // illumos will try the hint and if that fails allocate as if there were
 184   // no hint at all. The high hint prevents the break from getting hemmed in
 185   // at low values, ceding half of the address space to the system heap.
 186   raw_addr += 0x80000000;
 187 # else
 188   // The range 0x20000000 - 0x60000000 is relatively unpopulated across a
 189   // variety of ASLR modes (PAE kernel, NX compat mode, etc) and on macos
 190   // 10.6 and 10.7.
 191   raw_addr += 0x20000000;
 192 # endif
 193 #endif
 194   return reinterpret_cast<void*>(raw_addr);
 195 }
 196
 197
 198 size_t OS::AllocateAlignment() {
 199   return static_cast<size_t>(sysconf(_SC_PAGESIZE));
 200 }
 201
 202
 203 void OS::Sleep(int milliseconds) {
 204   useconds_t ms = static_cast<useconds_t>(milliseconds);
 205   usleep(1000 * ms);
 206 }
 207
 208
 209 void OS::Abort() {
 210   if (g_hard_abort) {
 211     V8_IMMEDIATE_CRASH();
 212   }
 213   // Redirect to std abort to signal abnormal program termination.
 214   abort();
 215 }
 216
 217
 218 void OS::DebugBreak() {
 219 #if V8_HOST_ARCH_ARM
 220   asm("bkpt 0");
 221 #elif V8_HOST_ARCH_ARM64
 222   asm("brk 0");
 223 #elif V8_HOST_ARCH_MIPS
 224   asm("break");
 225 #elif V8_HOST_ARCH_MIPS64
 226   asm("break");
 227 #elif V8_HOST_ARCH_IA32
 228 #if V8_OS_NACL
 229   asm("hlt");
 230 #else
 231   asm("int $3");
 232 #endif  // V8_OS_NACL
 233 #elif V8_HOST_ARCH_X64
 234   asm("int $3");
 235 #else
 236 #error Unsupported host architecture.
 237 #endif
 238 }
 239
 240
 241 // ----------------------------------------------------------------------------
 242 // Math functions
 243
 244 double OS::nan_value() {
 245   // NAN from math.h is defined in C99 and not in POSIX.
 246   return NAN;
 247 }
 248
 249
 250 int OS::GetCurrentProcessId() {
 251   return static_cast<int>(getpid());
 252 }
 253
 254
 255 int OS::GetCurrentThreadId() {
 256 #if V8_OS_MACOSX
 257   return static_cast<int>(pthread_mach_thread_np(pthread_self()));
 258 #elif V8_OS_LINUX
 259   return static_cast<int>(syscall(__NR_gettid));
 260 #elif V8_OS_ANDROID
 261   return static_cast<int>(gettid());
 262 #else
 263   return static_cast<int>(pthread_self());
 264 #endif
 265 }
 266
 267
 268 // ----------------------------------------------------------------------------
 269 // POSIX date/time support.
 270 //
 271
 272 int OS::GetUserTime(uint32_t* secs,  uint32_t* usecs) {
 273 #if V8_OS_NACL
 274   // Optionally used in Logger::ResourceEvent.
 275   return -1;
 276 #else
 277   struct rusage usage;
 278
 279   if (getrusage(RUSAGE_SELF, &usage) < 0) return -1;
 280   *secs = usage.ru_utime.tv_sec;
 281   *usecs = usage.ru_utime.tv_usec;
 282   return 0;
 283 #endif
 284 }
 285
 286
 287 double OS::TimeCurrentMillis() {
 288   return Time::Now().ToJsTime();
 289 }
 290
 291
 292 class TimezoneCache {};
 293
 294
 295 TimezoneCache* OS::CreateTimezoneCache() {
 296   return NULL;
 297 }
 298
 299
 300 void OS::DisposeTimezoneCache(TimezoneCache* cache) {
 301   DCHECK(cache == NULL);
 302 }
 303
 304
 305 void OS::ClearTimezoneCache(TimezoneCache* cache) {
 306   DCHECK(cache == NULL);
 307 }
 308
 309
 310 double OS::DaylightSavingsOffset(double time, TimezoneCache*) {
 311   if (std::isnan(time)) return nan_value();
 312   time_t tv = static_cast<time_t>(std::floor(time/msPerSecond));
 313   struct tm* t = localtime(&tv);
 314   if (NULL == t) return nan_value();
 315   return t->tm_isdst > 0 ? 3600 * msPerSecond : 0;
 316 }
 317
 318
 319 int OS::GetLastError() {
 320   return errno;
 321 }
 322
 323
 324 // ----------------------------------------------------------------------------
 325 // POSIX stdio support.
 326 //
 327
 328 FILE* OS::FOpen(const char* path, const char* mode) {
 329   FILE* file = fopen(path, mode);
 330   if (file == NULL) return NULL;
 331   struct stat file_stat;
 332   if (fstat(fileno(file), &file_stat) != 0) return NULL;
 333   bool is_regular_file = ((file_stat.st_mode & S_IFREG) != 0);
 334   if (is_regular_file) return file;
 335   fclose(file);
 336   return NULL;
 337 }
 338
 339
 340 bool OS::Remove(const char* path) {
 341   return (remove(path) == 0);
 342 }
 343
 344
 345 FILE* OS::OpenTemporaryFile() {
 346   return tmpfile();
 347 }
 348
 349
 350 const char* const OS::LogFileOpenMode = "w";
 351
 352
 353 void OS::Print(const char* format, ...) {
 354   va_list args;
 355   va_start(args, format);
 356   VPrint(format, args);
 357   va_end(args);
 358 }
 359
 360
 361 void OS::VPrint(const char* format, va_list args) {
 362 #if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
 363   __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
 364 #else
 365   vprintf(format, args);
 366 #endif
 367 }
 368
 369
 370 void OS::FPrint(FILE* out, const char* format, ...) {
 371   va_list args;
 372   va_start(args, format);
 373   VFPrint(out, format, args);
 374   va_end(args);
 375 }
 376
 377
 378 void OS::VFPrint(FILE* out, const char* format, va_list args) {
 379 #if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
 380   __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
 381 #else
 382   vfprintf(out, format, args);
 383 #endif
 384 }
 385
 386
 387 void OS::PrintError(const char* format, ...) {
 388   va_list args;
 389   va_start(args, format);
 390   VPrintError(format, args);
 391   va_end(args);
 392 }
 393
 394
 395 void OS::VPrintError(const char* format, va_list args) {
 396 #if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
 397   __android_log_vprint(ANDROID_LOG_ERROR, LOG_TAG, format, args);
 398 #else
 399   vfprintf(stderr, format, args);
 400 #endif
 401 }
 402
 403
 404 int OS::SNPrintF(char* str, int length, const char* format, ...) {
 405   va_list args;
 406   va_start(args, format);
 407   int result = VSNPrintF(str, length, format, args);
 408   va_end(args);
 409   return result;
 410 }
 411
 412
 413 int OS::VSNPrintF(char* str,
 414                   int length,
 415                   const char* format,
 416                   va_list args) {
 417   int n = vsnprintf(str, length, format, args);
 418   if (n < 0 || n >= length) {
 419     // If the length is zero, the assignment fails.
 420     if (length > 0)
 421       str[length - 1] = '\0';
 422     return -1;
 423   } else {
 424     return n;
 425   }
 426 }
 427
 428
 429 // ----------------------------------------------------------------------------
 430 // POSIX string support.
 431 //
 432
 433 char* OS::StrChr(char* str, int c) {
 434   return strchr(str, c);
 435 }
 436
 437
 438 void OS::StrNCpy(char* dest, int length, const char* src, size_t n) {
 439   strncpy(dest, src, n);
 440 }
 441
 442
 443 // ----------------------------------------------------------------------------
 444 // POSIX thread support.
 445 //
 446
 447 class Thread::PlatformData {
 448  public:
 449   PlatformData() : thread_(kNoThread) {}
 450   pthread_t thread_;  // Thread handle for pthread.
 451   // Synchronizes thread creation
 452   Mutex thread_creation_mutex_;
 453 };
 454
 455 Thread::Thread(const Options& options)
 456     : data_(new PlatformData),
 457       stack_size_(options.stack_size()),
 458       start_semaphore_(NULL) {
 459   if (stack_size_ > 0 && static_cast<size_t>(stack_size_) < PTHREAD_STACK_MIN) {
 460     stack_size_ = PTHREAD_STACK_MIN;
 461   }
 462   set_name(options.name());
 463 }
 464
 465
 466 Thread::~Thread() {
 467   delete data_;
 468 }
 469
 470
 471 static void SetThreadName(const char* name) {
 472 #if V8_OS_DRAGONFLYBSD || V8_OS_FREEBSD || V8_OS_OPENBSD
 473   pthread_set_name_np(pthread_self(), name);
 474 #elif V8_OS_NETBSD
 475   STATIC_ASSERT(Thread::kMaxThreadNameLength <= PTHREAD_MAX_NAMELEN_NP);
 476   pthread_setname_np(pthread_self(), "%s", name);
 477 #elif V8_OS_MACOSX
 478   // pthread_setname_np is only available in 10.6 or later, so test
 479   // for it at runtime.
 480   int (*dynamic_pthread_setname_np)(const char*);
 481   *reinterpret_cast<void**>(&dynamic_pthread_setname_np) =
 482     dlsym(RTLD_DEFAULT, "pthread_setname_np");
 483   if (dynamic_pthread_setname_np == NULL)
 484     return;
 485
 486   // Mac OS X does not expose the length limit of the name, so hardcode it.
 487   static const int kMaxNameLength = 63;
 488   STATIC_ASSERT(Thread::kMaxThreadNameLength <= kMaxNameLength);
 489   dynamic_pthread_setname_np(name);
 490 #elif defined(PR_SET_NAME)
 491   prctl(PR_SET_NAME,
 492         reinterpret_cast<unsigned long>(name),  // NOLINT
 493         0, 0, 0);
 494 #endif
 495 }
 496
 497
 498 static void* ThreadEntry(void* arg) {
 499   Thread* thread = reinterpret_cast<Thread*>(arg);
 500   // We take the lock here to make sure that pthread_create finished first since
 501   // we don't know which thread will run first (the original thread or the new
 502   // one).
 503   { LockGuard<Mutex> lock_guard(&thread->data()->thread_creation_mutex_); }
 504   SetThreadName(thread->name());
 505   DCHECK(thread->data()->thread_ != kNoThread);
 506   thread->NotifyStartedAndRun();
 507   return NULL;
 508 }
 509
 510
 511 void Thread::set_name(const char* name) {
 512   strncpy(name_, name, sizeof(name_));
 513   name_[sizeof(name_) - 1] = '\0';
 514 }
 515
 516
 517 void Thread::Start() {
 518   int result;
 519   pthread_attr_t attr;
 520   memset(&attr, 0, sizeof(attr));
 521   result = pthread_attr_init(&attr);
 522   DCHECK_EQ(0, result);
 523   // Native client uses default stack size.
 524 #if !V8_OS_NACL
 525   if (stack_size_ > 0) {
 526     result = pthread_attr_setstacksize(&attr, static_cast<size_t>(stack_size_));
 527     DCHECK_EQ(0, result);
 528   }
 529 #endif
 530   {
 531     LockGuard<Mutex> lock_guard(&data_->thread_creation_mutex_);
 532     result = pthread_create(&data_->thread_, &attr, ThreadEntry, this);
 533   }
 534   DCHECK_EQ(0, result);
 535   result = pthread_attr_destroy(&attr);
 536   DCHECK_EQ(0, result);
 537   DCHECK(data_->thread_ != kNoThread);
 538   USE(result);
 539 }
 540
 541
 542 void Thread::Join() {
 543   pthread_join(data_->thread_, NULL);
 544 }
 545
 546
 547 void Thread::YieldCPU() {
 548   int result = sched_yield();
 549   DCHECK_EQ(0, result);
 550   USE(result);
 551 }
 552
 553
 554 static Thread::LocalStorageKey PthreadKeyToLocalKey(pthread_key_t pthread_key) {
 555 #if V8_OS_CYGWIN
 556   // We need to cast pthread_key_t to Thread::LocalStorageKey in two steps
 557   // because pthread_key_t is a pointer type on Cygwin. This will probably not
 558   // work on 64-bit platforms, but Cygwin doesn't support 64-bit anyway.
 559   STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
 560   intptr_t ptr_key = reinterpret_cast<intptr_t>(pthread_key);
 561   return static_cast<Thread::LocalStorageKey>(ptr_key);
 562 #else
 563   return static_cast<Thread::LocalStorageKey>(pthread_key);
 564 #endif
 565 }
 566
 567
 568 static pthread_key_t LocalKeyToPthreadKey(Thread::LocalStorageKey local_key) {
 569 #if V8_OS_CYGWIN
 570   STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
 571   intptr_t ptr_key = static_cast<intptr_t>(local_key);
 572   return reinterpret_cast<pthread_key_t>(ptr_key);
 573 #else
 574   return static_cast<pthread_key_t>(local_key);
 575 #endif
 576 }
 577
 578
 579 #ifdef V8_FAST_TLS_SUPPORTED
 580
 581 static Atomic32 tls_base_offset_initialized = 0;
 582 intptr_t kMacTlsBaseOffset = 0;
 583
 584 // It's safe to do the initialization more that once, but it has to be
 585 // done at least once.
 586 static void InitializeTlsBaseOffset() {
 587   const size_t kBufferSize = 128;
 588   char buffer[kBufferSize];
 589   size_t buffer_size = kBufferSize;
 590   int ctl_name[] = { CTL_KERN , KERN_OSRELEASE };
 591   if (sysctl(ctl_name, 2, buffer, &buffer_size, NULL, 0) != 0) {
 592     V8_Fatal(__FILE__, __LINE__, "V8 failed to get kernel version");
 593   }
 594   // The buffer now contains a string of the form XX.YY.ZZ, where
 595   // XX is the major kernel version component.
 596   // Make sure the buffer is 0-terminated.
 597   buffer[kBufferSize - 1] = '\0';
 598   char* period_pos = strchr(buffer, '.');
 599   *period_pos = '\0';
 600   int kernel_version_major =
 601       static_cast<int>(strtol(buffer, NULL, 10));  // NOLINT
 602   // The constants below are taken from pthreads.s from the XNU kernel
 603   // sources archive at www.opensource.apple.com.
 604   if (kernel_version_major < 11) {
 605     // 8.x.x (Tiger), 9.x.x (Leopard), 10.x.x (Snow Leopard) have the
 606     // same offsets.
 607 #if V8_HOST_ARCH_IA32
 608     kMacTlsBaseOffset = 0x48;
 609 #else
 610     kMacTlsBaseOffset = 0x60;
 611 #endif
 612   } else {
 613     // 11.x.x (Lion) changed the offset.
 614     kMacTlsBaseOffset = 0;
 615   }
 616
 617   Release_Store(&tls_base_offset_initialized, 1);
 618 }
 619
 620
 621 static void CheckFastTls(Thread::LocalStorageKey key) {
 622   void* expected = reinterpret_cast<void*>(0x1234CAFE);
 623   Thread::SetThreadLocal(key, expected);
 624   void* actual = Thread::GetExistingThreadLocal(key);
 625   if (expected != actual) {
 626     V8_Fatal(__FILE__, __LINE__,
 627              "V8 failed to initialize fast TLS on current kernel");
 628   }
 629   Thread::SetThreadLocal(key, NULL);
 630 }
 631
 632 #endif  // V8_FAST_TLS_SUPPORTED
 633
 634
 635 Thread::LocalStorageKey Thread::CreateThreadLocalKey() {
 636 #ifdef V8_FAST_TLS_SUPPORTED
 637   bool check_fast_tls = false;
 638   if (tls_base_offset_initialized == 0) {
 639     check_fast_tls = true;
 640     InitializeTlsBaseOffset();
 641   }
 642 #endif
 643   pthread_key_t key;
 644   int result = pthread_key_create(&key, NULL);
 645   DCHECK_EQ(0, result);
 646   USE(result);
 647   LocalStorageKey local_key = PthreadKeyToLocalKey(key);
 648 #ifdef V8_FAST_TLS_SUPPORTED
 649   // If we just initialized fast TLS support, make sure it works.
 650   if (check_fast_tls) CheckFastTls(local_key);
 651 #endif
 652   return local_key;
 653 }
 654
 655
 656 void Thread::DeleteThreadLocalKey(LocalStorageKey key) {
 657   pthread_key_t pthread_key = LocalKeyToPthreadKey(key);
 658   int result = pthread_key_delete(pthread_key);
 659   DCHECK_EQ(0, result);
 660   USE(result);
 661 }
 662
 663
 664 void* Thread::GetThreadLocal(LocalStorageKey key) {
 665   pthread_key_t pthread_key = LocalKeyToPthreadKey(key);
 666   return pthread_getspecific(pthread_key);
 667 }
 668
 669
 670 void Thread::SetThreadLocal(LocalStorageKey key, void* value) {
 671   pthread_key_t pthread_key = LocalKeyToPthreadKey(key);
 672   int result = pthread_setspecific(pthread_key, value);
 673   DCHECK_EQ(0, result);
 674   USE(result);
 675 }
 676
 677
 678 } }  // namespace v8::base