The Tor Browser: js/src/assembler/jit/ExecutableAllocatorPosix.cpp@925c144e1f1f

     1 /*

     2  * Copyright (C) 2008 Apple Inc. All rights reserved.

     3  *

     4  * Redistribution and use in source and binary forms, with or without

     5  * modification, are permitted provided that the following conditions

     6  * are met:

     7  * 1. Redistributions of source code must retain the above copyright

     8  *    notice, this list of conditions and the following disclaimer.

     9  * 2. Redistributions in binary form must reproduce the above copyright

    10  *    notice, this list of conditions and the following disclaimer in the

    11  *    documentation and/or other materials provided with the distribution.

    12  *

    13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

    14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

    17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    24  */

    26 #include "assembler/jit/ExecutableAllocator.h"

    28 #if ENABLE_ASSEMBLER && WTF_OS_UNIX && !WTF_OS_SYMBIAN

    30 #include <sys/mman.h>

    31 #include <unistd.h>

    33 #include "assembler/wtf/Assertions.h"

    34 #include "assembler/wtf/VMTags.h"

    35 #include "js/Utility.h"

    37 namespace JSC {

    39 size_t ExecutableAllocator::determinePageSize()

    40 {

    41     return getpagesize();

    42 }

    44 ExecutablePool::Allocation ExecutableAllocator::systemAlloc(size_t n)

    45 {

    46     void *allocation = mmap(NULL, n, INITIAL_PROTECTION_FLAGS, MAP_PRIVATE | MAP_ANON, VM_TAG_FOR_EXECUTABLEALLOCATOR_MEMORY, 0);

    47     if (allocation == MAP_FAILED)

    48         allocation = NULL;

    49     ExecutablePool::Allocation alloc = { reinterpret_cast<char*>(allocation), n };

    50     return alloc;

    51 }

    53 void ExecutableAllocator::systemRelease(const ExecutablePool::Allocation& alloc)

    54 {

    55     int result = munmap(alloc.pages, alloc.size);

    56     ASSERT_UNUSED(result, !result);

    57 }

    59 #if WTF_ENABLE_ASSEMBLER_WX_EXCLUSIVE

    60 void ExecutableAllocator::reprotectRegion(void* start, size_t size, ProtectionSetting setting)

    61 {

    62     if (!pageSize)

    63         intializePageSize();

    65     // Calculate the start of the page containing this region,

    66     // and account for this extra memory within size.

    67     intptr_t startPtr = reinterpret_cast<intptr_t>(start);

    68     intptr_t pageStartPtr = startPtr & ~(pageSize - 1);

    69     void* pageStart = reinterpret_cast<void*>(pageStartPtr);

    70     size += (startPtr - pageStartPtr);

    72     // Round size up

    73     size += (pageSize - 1);

    74     size &= ~(pageSize - 1);

    76     mprotect(pageStart, size, (setting == Writable) ? PROTECTION_FLAGS_RW : PROTECTION_FLAGS_RX);

    77 }

    78 #endif

    80 #if WTF_CPU_ARM_TRADITIONAL && WTF_OS_LINUX && WTF_COMPILER_RVCT

    81 __asm void ExecutableAllocator::cacheFlush(void* code, size_t size)

    82 {

    83     ARM

    84     push {r7}

    85     add r1, r1, r0

    86     mov r7, #0xf0000

    87     add r7, r7, #0x2

    88     mov r2, #0x0

    89     svc #0x0

    90     pop {r7}

    91     bx lr

    92 }

    93 #endif

    95 void

    96 ExecutablePool::toggleAllCodeAsAccessible(bool accessible)

    97 {

    98     char* begin = m_allocation.pages;

    99     size_t size = m_freePtr - begin;

   101     if (size) {

   102         // N.B. Some systems, like 32bit Mac OS 10.6, implicitly add PROT_EXEC

   103         // when mprotect'ing memory with any flag other than PROT_NONE. Be

   104         // sure to use PROT_NONE when making inaccessible.

   105         int flags = accessible ? PROT_READ | PROT_WRITE | PROT_EXEC : PROT_NONE;

   106         if (mprotect(begin, size, flags))

   107             MOZ_CRASH();

   108     }

   109 }

   111 }

   113 #endif // HAVE(ASSEMBLER)

The Tor Browser / file revision