OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright (C) 2013 Google 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 are | |
6 * met: | |
7 * | |
8 * * Redistributions of source code must retain the above copyright | |
9 * notice, this list of conditions and the following disclaimer. | |
10 * * Redistributions in binary form must reproduce the above | |
11 * copyright notice, this list of conditions and the following disclaimer | |
12 * in the documentation and/or other materials provided with the | |
13 * distribution. | |
14 * * Neither the name of Google Inc. nor the names of its | |
15 * contributors may be used to endorse or promote products derived from | |
16 * this software without specific prior written permission. | |
17 * | |
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
29 */ | |
30 | |
31 #ifndef WTF_PageAllocator_h | |
32 #define WTF_PageAllocator_h | |
33 | |
34 #include "wtf/Assertions.h" | |
35 #include "wtf/CPU.h" | |
36 #include "wtf/Compiler.h" | |
37 #include "wtf/WTFExport.h" | |
38 #include <cstddef> | |
39 #include <stdint.h> | |
40 | |
41 namespace WTF { | |
42 | |
43 #if OS(WIN) | |
44 static const size_t kPageAllocationGranularityShift = 16; // 64KB | |
45 #else | |
46 static const size_t kPageAllocationGranularityShift = 12; // 4KB | |
47 #endif | |
48 static const size_t kPageAllocationGranularity = | |
49 1 << kPageAllocationGranularityShift; | |
50 static const size_t kPageAllocationGranularityOffsetMask = | |
51 kPageAllocationGranularity - 1; | |
52 static const size_t kPageAllocationGranularityBaseMask = | |
53 ~kPageAllocationGranularityOffsetMask; | |
54 | |
55 // All Blink-supported systems have 4096 sized system pages and can handle | |
56 // permissions and commit / decommit at this granularity. | |
57 static const size_t kSystemPageSize = 4096; | |
58 static const size_t kSystemPageOffsetMask = kSystemPageSize - 1; | |
59 static const size_t kSystemPageBaseMask = ~kSystemPageOffsetMask; | |
60 | |
61 enum PageAccessibilityConfiguration { | |
62 PageAccessible, | |
63 PageInaccessible, | |
64 }; | |
65 | |
66 // Allocate one or more pages. | |
67 // The requested address is just a hint; the actual address returned may | |
68 // differ. The returned address will be aligned at least to align bytes. | |
69 // len is in bytes, and must be a multiple of kPageAllocationGranularity. | |
70 // align is in bytes, and must be a power-of-two multiple of | |
71 // kPageAllocationGranularity. | |
72 // If addr is null, then a suitable and randomized address will be chosen | |
73 // automatically. | |
74 // PageAccessibilityConfiguration controls the permission of the | |
75 // allocated pages. | |
76 // This call will return null if the allocation cannot be satisfied. | |
77 WTF_EXPORT void* allocPages(void* addr, | |
78 size_t len, | |
79 size_t align, | |
80 PageAccessibilityConfiguration); | |
81 | |
82 // Free one or more pages. | |
83 // addr and len must match a previous call to allocPages(). | |
84 WTF_EXPORT void freePages(void* addr, size_t len); | |
85 | |
86 // Mark one or more system pages as being inaccessible. | |
87 // Subsequently accessing any address in the range will fault, and the | |
88 // addresses will not be re-used by future allocations. | |
89 // len must be a multiple of kSystemPageSize bytes. | |
90 WTF_EXPORT void setSystemPagesInaccessible(void* addr, size_t len); | |
91 | |
92 // Mark one or more system pages as being accessible. | |
93 // The pages will be readable and writeable. | |
94 // len must be a multiple of kSystemPageSize bytes. | |
95 // The result bool value indicates whether the permission | |
96 // change succeeded or not. You must check the result | |
97 // (in most cases you need to RELEASE_ASSERT that it is | |
98 // true). | |
99 WTF_EXPORT WARN_UNUSED_RESULT bool setSystemPagesAccessible(void* addr, | |
100 size_t len); | |
101 | |
102 // Decommit one or more system pages. Decommitted means that the physical memory | |
103 // is released to the system, but the virtual address space remains reserved. | |
104 // System pages are re-committed by calling recommitSystemPages(). Touching | |
105 // a decommitted page _may_ fault. | |
106 // Clients should not make any assumptions about the contents of decommitted | |
107 // system pages, before or after they write to the page. The only guarantee | |
108 // provided is that the contents of the system page will be deterministic again | |
109 // after recommitting and writing to it. In particlar note that system pages are | |
110 // not guaranteed to be zero-filled upon re-commit. len must be a multiple of | |
111 // kSystemPageSize bytes. | |
112 WTF_EXPORT void decommitSystemPages(void* addr, size_t len); | |
113 | |
114 // Recommit one or more system pages. Decommitted system pages must be | |
115 // recommitted before they are read are written again. | |
116 // Note that this operation may be a no-op on some platforms. | |
117 // len must be a multiple of kSystemPageSize bytes. | |
118 WTF_EXPORT void recommitSystemPages(void* addr, size_t len); | |
119 | |
120 // Discard one or more system pages. Discarding is a hint to the system that | |
121 // the page is no longer required. The hint may: | |
122 // - Do nothing. | |
123 // - Discard the page immediately, freeing up physical pages. | |
124 // - Discard the page at some time in the future in response to memory pressure. | |
125 // Only committed pages should be discarded. Discarding a page does not | |
126 // decommit it, and it is valid to discard an already-discarded page. | |
127 // A read or write to a discarded page will not fault. | |
128 // Reading from a discarded page may return the original page content, or a | |
129 // page full of zeroes. | |
130 // Writing to a discarded page is the only guaranteed way to tell the system | |
131 // that the page is required again. Once written to, the content of the page is | |
132 // guaranteed stable once more. After being written to, the page content may be | |
133 // based on the original page content, or a page of zeroes. | |
134 // len must be a multiple of kSystemPageSize bytes. | |
135 WTF_EXPORT void discardSystemPages(void* addr, size_t len); | |
136 | |
137 WTF_EXPORT ALWAYS_INLINE uintptr_t roundUpToSystemPage(uintptr_t address) { | |
138 return (address + kSystemPageOffsetMask) & kSystemPageBaseMask; | |
139 } | |
140 | |
141 WTF_EXPORT ALWAYS_INLINE uintptr_t roundDownToSystemPage(uintptr_t address) { | |
142 return address & kSystemPageBaseMask; | |
143 } | |
144 | |
145 // Only allowed inside WTF for investigating WTF::initializeWithoutV8 crashes. | |
146 // Guess, the function fails because of mmap (or VirtualAlloc) failure. | |
147 // The following function returns errno (or GetLastError code) when mmap | |
148 // (or VirtualAlloc) fails. | |
149 uint32_t getAllocPageErrorCode(); | |
150 | |
151 } // namespace WTF | |
152 | |
153 #endif // WTF_PageAllocator_h | |
OLD | NEW |