Avoid PageAllocator::s_allocPageErrorCode races.

third_party/WebKit/Source/wtf/allocator/PageAllocator.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "wtf/allocator/PageAllocator.h"
 
 #include "wtf/Assertions.h"
+#include "wtf/Atomics.h"
 #include "wtf/allocator/AddressSpaceRandomization.h"
 
 #include <limits.h>
 
 #if OS(POSIX)
 
 #include <errno.h>
 #include <sys/mman.h>
 
 #ifndef MADV_FREE
 #define MADV_FREE MADV_DONTNEED
 #endif
 
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
 // On POSIX memmap uses a nearby address if the hint address is blocked.
 static const bool kHintIsAdvisory = true;
-static uint32_t allocPageErrorCode = 0;
+static uint32_t s_allocPageErrorCode = 0;
 
 #elif OS(WIN)
 
 #include <windows.h>
 
 // VirtualAlloc will fail if allocation at the hint address is blocked.
 static const bool kHintIsAdvisory = false;
-static uint32_t allocPageErrorCode = ERROR_SUCCESS;
+static uint32_t s_allocPageErrorCode = ERROR_SUCCESS;
 
 #else
 #error Unknown OS
 #endif // OS(POSIX)
 
 namespace WTF {
 
 // This internal function wraps the OS-specific page allocation call. The
 // behavior of the hint address is determined by the kHintIsAdvisory constant.
 // If true, a non-zero hint is advisory and the returned address may differ from
 // the hint. If false, the hint is mandatory and a successful allocation will
 // not differ from the hint.
 static void* systemAllocPages(void* hint, size_t len, PageAccessibilityConfiguration pageAccessibility)
 {
     ASSERT(!(len & kPageAllocationGranularityOffsetMask));
     ASSERT(!(reinterpret_cast<uintptr_t>(hint) & kPageAllocationGranularityOffsetMask));
     void* ret;
 #if OS(WIN)
     DWORD accessFlag = pageAccessibility == PageAccessible ? PAGE_READWRITE : PAGE_NOACCESS;
     ret = VirtualAlloc(hint, len, MEM_RESERVE | MEM_COMMIT, accessFlag);
     if (!ret)
-        allocPageErrorCode = GetLastError();
+        releaseStore(&s_allocPageErrorCode, GetLastError());
 #else
     int accessFlag = pageAccessibility == PageAccessible ? (PROT_READ | PROT_WRITE) : PROT_NONE;
     ret = mmap(hint, len, accessFlag, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
     if (ret == MAP_FAILED) {
-        allocPageErrorCode = errno;
+        releaseStore(&s_allocPageErrorCode, errno);
         ret = 0;
     }
 #endif
     return ret;
 }
 
 // Trims base to given length and alignment. Windows returns null on failure and frees base.
 static void* trimMapping(void *base, size_t baseLen, size_t trimLen, uintptr_t align, PageAccessibilityConfiguration pageAccessibility)
 {
     size_t preSlack = reinterpret_cast<uintptr_t>(base) & (align - 1);
@@ skipping 164 matching lines @@
     // DiscardVirtualMemory is buggy in Win10 SP0, so fall back to MEM_RESET on failure.
     if (ret) {
         void* ret = VirtualAlloc(addr, len, MEM_RESET, PAGE_READWRITE);
         RELEASE_ASSERT(ret);
     }
 #endif
 }
 
 uint32_t getAllocPageErrorCode()
 {
-    return allocPageErrorCode;
+    return acquireLoad(&s_allocPageErrorCode);
 }
 
 } // namespace WTF