Mercurial > hg > truffle
annotate src/share/vm/memory/filemap.cpp @ 20304:a22acf6d7598
8048112: G1 Full GC needs to support the case when the very first region is not available
Summary: Refactor preparation for compaction during Full GC so that it lazily initializes the first compaction point. This also avoids problems later when the first region may not be committed. Also reviewed by K. Barrett.
Reviewed-by: brutisso
| author | tschatzl |
|---|---|
| date | Mon, 21 Jul 2014 10:00:31 +0200 |
| parents | 78bbf4d43a14 |
| children | ca6d25be853b 6e0cb14ce59b |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
12157
diff
changeset
|
2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/classLoader.hpp" | |
| 27 #include "classfile/symbolTable.hpp" | |
|
7174
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
28 #include "classfile/altHashing.hpp" |
| 1972 | 29 #include "memory/filemap.hpp" |
| 30 #include "runtime/arguments.hpp" | |
| 31 #include "runtime/java.hpp" | |
| 32 #include "runtime/os.hpp" | |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6725
diff
changeset
|
33 #include "services/memTracker.hpp" |
| 1972 | 34 #include "utilities/defaultStream.hpp" |
| 35 | |
| 0 | 36 # include <sys/stat.h> |
| 37 # include <errno.h> | |
| 38 | |
| 39 #ifndef O_BINARY // if defined (Win32) use binary files. | |
| 40 #define O_BINARY 0 // otherwise do nothing. | |
| 41 #endif | |
| 42 | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
12157
diff
changeset
|
43 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC |
| 0 | 44 |
| 45 extern address JVM_FunctionAtStart(); | |
| 46 extern address JVM_FunctionAtEnd(); | |
| 47 | |
| 605 | 48 // Complain and stop. All error conditions occurring during the writing of |
| 0 | 49 // an archive file should stop the process. Unrecoverable errors during |
| 50 // the reading of the archive file should stop the process. | |
| 51 | |
| 52 static void fail(const char *msg, va_list ap) { | |
| 53 // This occurs very early during initialization: tty is not initialized. | |
| 54 jio_fprintf(defaultStream::error_stream(), | |
| 605 | 55 "An error has occurred while processing the" |
| 0 | 56 " shared archive file.\n"); |
| 57 jio_vfprintf(defaultStream::error_stream(), msg, ap); | |
| 58 jio_fprintf(defaultStream::error_stream(), "\n"); | |
|
12157
35b99e7e0af2
8023381: VM fails to initialize in runtime/CDSCompressedKPtrs/XShareAuto.java runtime/SharedArchiveFile/CdsSameObjectAlignment.java
hseigel
parents:
12056
diff
changeset
|
59 // Do not change the text of the below message because some tests check for it. |
| 0 | 60 vm_exit_during_initialization("Unable to use shared archive.", NULL); |
| 61 } | |
| 62 | |
| 63 | |
| 64 void FileMapInfo::fail_stop(const char *msg, ...) { | |
| 65 va_list ap; | |
| 66 va_start(ap, msg); | |
| 67 fail(msg, ap); // Never returns. | |
| 68 va_end(ap); // for completeness. | |
| 69 } | |
| 70 | |
| 71 | |
| 72 // Complain and continue. Recoverable errors during the reading of the | |
| 73 // archive file may continue (with sharing disabled). | |
| 74 // | |
| 75 // If we continue, then disable shared spaces and close the file. | |
| 76 | |
| 77 void FileMapInfo::fail_continue(const char *msg, ...) { | |
| 78 va_list ap; | |
| 79 va_start(ap, msg); | |
| 80 if (RequireSharedSpaces) { | |
| 81 fail(msg, ap); | |
| 82 } | |
| 83 va_end(ap); | |
| 84 UseSharedSpaces = false; | |
| 85 close(); | |
| 86 } | |
| 87 | |
|
7174
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
88 // Fill in the fileMapInfo structure with data about this VM instance. |
| 0 | 89 |
|
7174
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
90 // This method copies the vm version info into header_version. If the version is too |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
91 // long then a truncated version, which has a hash code appended to it, is copied. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
92 // |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
93 // Using a template enables this method to verify that header_version is an array of |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
94 // length JVM_IDENT_MAX. This ensures that the code that writes to the CDS file and |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
95 // the code that reads the CDS file will both use the same size buffer. Hence, will |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
96 // use identical truncation. This is necessary for matching of truncated versions. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
97 template <int N> static void get_header_version(char (&header_version) [N]) { |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
98 assert(N == JVM_IDENT_MAX, "Bad header_version size"); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
99 |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
100 const char *vm_version = VM_Version::internal_vm_info_string(); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
101 const int version_len = (int)strlen(vm_version); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
102 |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
103 if (version_len < (JVM_IDENT_MAX-1)) { |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
104 strcpy(header_version, vm_version); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
105 |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
106 } else { |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
107 // Get the hash value. Use a static seed because the hash needs to return the same |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
108 // value over multiple jvm invocations. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
109 unsigned int hash = AltHashing::murmur3_32(8191, (const jbyte*)vm_version, version_len); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
110 |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
111 // Truncate the ident, saving room for the 8 hex character hash value. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
112 strncpy(header_version, vm_version, JVM_IDENT_MAX-9); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
113 |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
114 // Append the hash code as eight hex digits. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
115 sprintf(&header_version[JVM_IDENT_MAX-9], "%08x", hash); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
116 header_version[JVM_IDENT_MAX-1] = 0; // Null terminate. |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
117 } |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
118 } |
| 0 | 119 |
| 120 void FileMapInfo::populate_header(size_t alignment) { | |
| 121 _header._magic = 0xf00baba2; | |
| 122 _header._version = _current_version; | |
| 123 _header._alignment = alignment; | |
|
7461
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
124 _header._obj_alignment = ObjectAlignmentInBytes; |
| 0 | 125 |
| 126 // The following fields are for sanity checks for whether this archive | |
| 127 // will function correctly with this JVM and the bootclasspath it's | |
| 128 // invoked with. | |
| 129 | |
| 130 // JVM version string ... changes on each build. | |
|
7174
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
131 get_header_version(_header._jvm_ident); |
| 0 | 132 |
| 133 // Build checks on classpath and jar files | |
| 134 _header._num_jars = 0; | |
| 135 ClassPathEntry *cpe = ClassLoader::classpath_entry(0); | |
| 136 for ( ; cpe != NULL; cpe = cpe->next()) { | |
| 137 | |
| 138 if (cpe->is_jar_file()) { | |
| 139 if (_header._num_jars >= JVM_SHARED_JARS_MAX) { | |
| 140 fail_stop("Too many jar files to share.", NULL); | |
| 141 } | |
| 142 | |
| 143 // Jar file - record timestamp and file size. | |
| 144 struct stat st; | |
| 145 const char *path = cpe->name(); | |
| 146 if (os::stat(path, &st) != 0) { | |
| 147 // If we can't access a jar file in the boot path, then we can't | |
| 148 // make assumptions about where classes get loaded from. | |
| 149 fail_stop("Unable to open jar file %s.", path); | |
| 150 } | |
| 151 _header._jar[_header._num_jars]._timestamp = st.st_mtime; | |
| 152 _header._jar[_header._num_jars]._filesize = st.st_size; | |
| 153 _header._num_jars++; | |
| 154 } else { | |
| 155 | |
| 156 // If directories appear in boot classpath, they must be empty to | |
| 157 // avoid having to verify each individual class file. | |
| 158 const char* name = ((ClassPathDirEntry*)cpe)->name(); | |
| 159 if (!os::dir_is_empty(name)) { | |
| 160 fail_stop("Boot classpath directory %s is not empty.", name); | |
| 161 } | |
| 162 } | |
| 163 } | |
| 164 } | |
| 165 | |
| 166 | |
| 167 // Read the FileMapInfo information from the file. | |
| 168 | |
| 169 bool FileMapInfo::init_from_file(int fd) { | |
| 170 | |
| 171 size_t n = read(fd, &_header, sizeof(struct FileMapHeader)); | |
| 172 if (n != sizeof(struct FileMapHeader)) { | |
| 173 fail_continue("Unable to read the file header."); | |
| 174 return false; | |
| 175 } | |
| 176 if (_header._version != current_version()) { | |
| 177 fail_continue("The shared archive file has the wrong version."); | |
| 178 return false; | |
| 179 } | |
| 180 _file_offset = (long)n; | |
| 181 return true; | |
| 182 } | |
| 183 | |
| 184 | |
| 185 // Read the FileMapInfo information from the file. | |
| 186 bool FileMapInfo::open_for_read() { | |
| 187 _full_path = Arguments::GetSharedArchivePath(); | |
| 188 int fd = open(_full_path, O_RDONLY | O_BINARY, 0); | |
| 189 if (fd < 0) { | |
| 190 if (errno == ENOENT) { | |
| 191 // Not locating the shared archive is ok. | |
| 192 fail_continue("Specified shared archive not found."); | |
| 193 } else { | |
| 194 fail_continue("Failed to open shared archive file (%s).", | |
| 195 strerror(errno)); | |
| 196 } | |
| 197 return false; | |
| 198 } | |
| 199 | |
| 200 _fd = fd; | |
| 201 _file_open = true; | |
| 202 return true; | |
| 203 } | |
| 204 | |
| 205 | |
| 206 // Write the FileMapInfo information to the file. | |
| 207 | |
| 208 void FileMapInfo::open_for_write() { | |
| 209 _full_path = Arguments::GetSharedArchivePath(); | |
| 210 if (PrintSharedSpaces) { | |
| 211 tty->print_cr("Dumping shared data to file: "); | |
| 212 tty->print_cr(" %s", _full_path); | |
| 213 } | |
| 214 | |
|
7980
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
215 #ifdef _WINDOWS // On Windows, need WRITE permission to remove the file. |
|
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
216 chmod(_full_path, _S_IREAD | _S_IWRITE); |
|
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
217 #endif |
|
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
218 |
|
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
219 // Use remove() to delete the existing file because, on Unix, this will |
|
c4ef3380a70b
7197672: There are issues with shared data on windows
hseigel
parents:
7461
diff
changeset
|
220 // allow processes that have it open continued access to the file. |
| 0 | 221 remove(_full_path); |
| 222 int fd = open(_full_path, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0444); | |
| 223 if (fd < 0) { | |
| 224 fail_stop("Unable to create shared archive file %s.", _full_path); | |
| 225 } | |
| 226 _fd = fd; | |
| 227 _file_offset = 0; | |
| 228 _file_open = true; | |
| 229 } | |
| 230 | |
| 231 | |
| 232 // Write the header to the file, seek to the next allocation boundary. | |
| 233 | |
| 234 void FileMapInfo::write_header() { | |
| 235 write_bytes_aligned(&_header, sizeof(FileMapHeader)); | |
| 236 } | |
| 237 | |
| 238 | |
| 239 // Dump shared spaces to file. | |
| 240 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
241 void FileMapInfo::write_space(int i, Metaspace* space, bool read_only) { |
| 0 | 242 align_file_position(); |
|
10183
868d87ed63c8
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
8804
diff
changeset
|
243 size_t used = space->used_bytes_slow(Metaspace::NonClassType); |
|
868d87ed63c8
8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions
jmasa
parents:
8804
diff
changeset
|
244 size_t capacity = space->capacity_bytes_slow(Metaspace::NonClassType); |
| 0 | 245 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
246 write_region(i, (char*)space->bottom(), used, capacity, read_only, false); |
| 0 | 247 } |
| 248 | |
| 249 | |
| 250 // Dump region to file. | |
| 251 | |
| 252 void FileMapInfo::write_region(int region, char* base, size_t size, | |
| 253 size_t capacity, bool read_only, | |
| 254 bool allow_exec) { | |
| 255 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[region]; | |
| 256 | |
| 257 if (_file_open) { | |
| 258 guarantee(si->_file_offset == _file_offset, "file offset mismatch."); | |
| 259 if (PrintSharedSpaces) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
260 tty->print_cr("Shared file region %d: 0x%6x bytes, addr " INTPTR_FORMAT |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
261 " file offset 0x%6x", region, size, base, _file_offset); |
| 0 | 262 } |
| 263 } else { | |
| 264 si->_file_offset = _file_offset; | |
| 265 } | |
| 266 si->_base = base; | |
| 267 si->_used = size; | |
| 268 si->_capacity = capacity; | |
| 269 si->_read_only = read_only; | |
| 270 si->_allow_exec = allow_exec; | |
| 271 write_bytes_aligned(base, (int)size); | |
| 272 } | |
| 273 | |
| 274 | |
| 275 // Dump bytes to file -- at the current file position. | |
| 276 | |
| 277 void FileMapInfo::write_bytes(const void* buffer, int nbytes) { | |
| 278 if (_file_open) { | |
| 279 int n = ::write(_fd, buffer, nbytes); | |
| 280 if (n != nbytes) { | |
| 281 // It is dangerous to leave the corrupted shared archive file around, | |
| 282 // close and remove the file. See bug 6372906. | |
| 283 close(); | |
| 284 remove(_full_path); | |
| 285 fail_stop("Unable to write to shared archive file.", NULL); | |
| 286 } | |
| 287 } | |
| 288 _file_offset += nbytes; | |
| 289 } | |
| 290 | |
| 291 | |
| 292 // Align file position to an allocation unit boundary. | |
| 293 | |
| 294 void FileMapInfo::align_file_position() { | |
| 295 long new_file_offset = align_size_up(_file_offset, os::vm_allocation_granularity()); | |
| 296 if (new_file_offset != _file_offset) { | |
| 297 _file_offset = new_file_offset; | |
| 298 if (_file_open) { | |
| 299 // Seek one byte back from the target and write a byte to insure | |
| 300 // that the written file is the correct length. | |
| 301 _file_offset -= 1; | |
| 302 if (lseek(_fd, _file_offset, SEEK_SET) < 0) { | |
| 303 fail_stop("Unable to seek.", NULL); | |
| 304 } | |
| 305 char zero = 0; | |
| 306 write_bytes(&zero, 1); | |
| 307 } | |
| 308 } | |
| 309 } | |
| 310 | |
| 311 | |
| 312 // Dump bytes to file -- at the current file position. | |
| 313 | |
| 314 void FileMapInfo::write_bytes_aligned(const void* buffer, int nbytes) { | |
| 315 align_file_position(); | |
| 316 write_bytes(buffer, nbytes); | |
| 317 align_file_position(); | |
| 318 } | |
| 319 | |
| 320 | |
| 321 // Close the shared archive file. This does NOT unmap mapped regions. | |
| 322 | |
| 323 void FileMapInfo::close() { | |
| 324 if (_file_open) { | |
| 325 if (::close(_fd) < 0) { | |
| 326 fail_stop("Unable to close the shared archive file."); | |
| 327 } | |
| 328 _file_open = false; | |
| 329 _fd = -1; | |
| 330 } | |
| 331 } | |
| 332 | |
| 333 | |
| 334 // JVM/TI RedefineClasses() support: | |
| 335 // Remap the shared readonly space to shared readwrite, private. | |
| 336 bool FileMapInfo::remap_shared_readonly_as_readwrite() { | |
| 337 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[0]; | |
| 338 if (!si->_read_only) { | |
| 339 // the space is already readwrite so we are done | |
| 340 return true; | |
| 341 } | |
| 342 size_t used = si->_used; | |
| 343 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 344 if (!open_for_read()) { | |
| 345 return false; | |
| 346 } | |
| 347 char *base = os::remap_memory(_fd, _full_path, si->_file_offset, | |
| 348 si->_base, size, false /* !read_only */, | |
| 349 si->_allow_exec); | |
| 350 close(); | |
| 351 if (base == NULL) { | |
| 352 fail_continue("Unable to remap shared readonly space (errno=%d).", errno); | |
| 353 return false; | |
| 354 } | |
| 355 if (base != si->_base) { | |
| 356 fail_continue("Unable to remap shared readonly space at required address."); | |
| 357 return false; | |
| 358 } | |
| 359 si->_read_only = false; | |
| 360 return true; | |
| 361 } | |
| 362 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
363 // Map the whole region at once, assumed to be allocated contiguously. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
364 ReservedSpace FileMapInfo::reserve_shared_memory() { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
365 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[0]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
366 char* requested_addr = si->_base; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
367 |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
368 size_t size = FileMapInfo::shared_spaces_size(); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
369 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
370 // Reserve the space first, then map otherwise map will go right over some |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
371 // other reserved memory (like the code cache). |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
372 ReservedSpace rs(size, os::vm_allocation_granularity(), false, requested_addr); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
373 if (!rs.is_reserved()) { |
|
8804
91bf0bdae37b
8008217: CDS: Class data sharing limits the malloc heap on Solaris
coleenp
parents:
7980
diff
changeset
|
374 fail_continue(err_msg("Unable to reserve shared space at required address " INTPTR_FORMAT, requested_addr)); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
375 return rs; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
376 } |
|
6882
716c64bda5ba
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
6725
diff
changeset
|
377 // the reserved virtual memory is for mapping class data sharing archive |
|
7460
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
378 MemTracker::record_virtual_memory_type((address)rs.base(), mtClassShared); |
|
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
379 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
380 return rs; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
381 } |
| 0 | 382 |
| 383 // Memory map a region in the address space. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
384 static const char* shared_region_name[] = { "ReadOnly", "ReadWrite", "MiscData", "MiscCode"}; |
| 0 | 385 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
386 char* FileMapInfo::map_region(int i) { |
| 0 | 387 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; |
| 388 size_t used = si->_used; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
389 size_t alignment = os::vm_allocation_granularity(); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
390 size_t size = align_size_up(used, alignment); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
391 char *requested_addr = si->_base; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
392 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
393 // map the contents of the CDS archive in this memory |
| 0 | 394 char *base = os::map_memory(_fd, _full_path, si->_file_offset, |
| 395 requested_addr, size, si->_read_only, | |
| 396 si->_allow_exec); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
397 if (base == NULL || base != si->_base) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
398 fail_continue(err_msg("Unable to map %s shared space at required address.", shared_region_name[i])); |
| 0 | 399 return NULL; |
| 400 } | |
|
7460
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
401 #ifdef _WINDOWS |
|
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
402 // This call is Windows-only because the memory_type gets recorded for the other platforms |
|
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
403 // in method FileMapInfo::reserve_shared_memory(), which is not called on Windows. |
|
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
404 MemTracker::record_virtual_memory_type((address)base, mtClassShared); |
|
6c3f47d964f3
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
7174
diff
changeset
|
405 #endif |
| 0 | 406 return base; |
| 407 } | |
| 408 | |
| 409 | |
| 410 // Unmap a memory region in the address space. | |
| 411 | |
| 412 void FileMapInfo::unmap_region(int i) { | |
| 413 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 414 size_t used = si->_used; | |
| 415 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 416 if (!os::unmap_memory(si->_base, size)) { | |
| 417 fail_stop("Unable to unmap shared space."); | |
| 418 } | |
| 419 } | |
| 420 | |
| 421 | |
| 422 void FileMapInfo::assert_mark(bool check) { | |
| 423 if (!check) { | |
| 424 fail_stop("Mark mismatch while restoring from shared file.", NULL); | |
| 425 } | |
| 426 } | |
| 427 | |
| 428 | |
| 429 FileMapInfo* FileMapInfo::_current_info = NULL; | |
| 430 | |
| 431 | |
| 432 // Open the shared archive file, read and validate the header | |
| 433 // information (version, boot classpath, etc.). If initialization | |
| 434 // fails, shared spaces are disabled and the file is closed. [See | |
| 435 // fail_continue.] | |
| 436 bool FileMapInfo::initialize() { | |
| 437 assert(UseSharedSpaces, "UseSharedSpaces expected."); | |
| 438 | |
| 439 if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space()) { | |
| 440 fail_continue("Tool agent requires sharing to be disabled."); | |
| 441 return false; | |
| 442 } | |
| 443 | |
| 444 if (!open_for_read()) { | |
| 445 return false; | |
| 446 } | |
| 447 | |
| 448 init_from_file(_fd); | |
| 449 if (!validate()) { | |
| 450 return false; | |
| 451 } | |
| 452 | |
| 453 SharedReadOnlySize = _header._space[0]._capacity; | |
| 454 SharedReadWriteSize = _header._space[1]._capacity; | |
| 455 SharedMiscDataSize = _header._space[2]._capacity; | |
| 456 SharedMiscCodeSize = _header._space[3]._capacity; | |
| 457 return true; | |
| 458 } | |
| 459 | |
| 460 | |
| 461 bool FileMapInfo::validate() { | |
| 462 if (_header._version != current_version()) { | |
| 463 fail_continue("The shared archive file is the wrong version."); | |
| 464 return false; | |
| 465 } | |
| 466 if (_header._magic != (int)0xf00baba2) { | |
| 467 fail_continue("The shared archive file has a bad magic number."); | |
| 468 return false; | |
| 469 } | |
|
7174
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
470 char header_version[JVM_IDENT_MAX]; |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
471 get_header_version(header_version); |
|
fe81517cfb77
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
6882
diff
changeset
|
472 if (strncmp(_header._jvm_ident, header_version, JVM_IDENT_MAX-1) != 0) { |
| 0 | 473 fail_continue("The shared archive file was created by a different" |
| 474 " version or build of HotSpot."); | |
| 475 return false; | |
| 476 } | |
|
7461
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
477 if (_header._obj_alignment != ObjectAlignmentInBytes) { |
|
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
478 fail_continue("The shared archive file's ObjectAlignmentInBytes of %d" |
|
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
479 " does not equal the current ObjectAlignmentInBytes of %d.", |
|
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
480 _header._obj_alignment, ObjectAlignmentInBytes); |
|
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
481 return false; |
|
561148896559
8005076: Creating a CDS archive with one alignment and running another causes a crash.
hseigel
parents:
7460
diff
changeset
|
482 } |
| 0 | 483 |
| 484 // Cannot verify interpreter yet, as it can only be created after the GC | |
| 485 // heap has been initialized. | |
| 486 | |
| 487 if (_header._num_jars >= JVM_SHARED_JARS_MAX) { | |
| 488 fail_continue("Too many jar files to share."); | |
| 489 return false; | |
| 490 } | |
| 491 | |
| 492 // Build checks on classpath and jar files | |
| 493 int num_jars_now = 0; | |
| 494 ClassPathEntry *cpe = ClassLoader::classpath_entry(0); | |
| 495 for ( ; cpe != NULL; cpe = cpe->next()) { | |
| 496 | |
| 497 if (cpe->is_jar_file()) { | |
| 498 if (num_jars_now < _header._num_jars) { | |
| 499 | |
| 500 // Jar file - verify timestamp and file size. | |
| 501 struct stat st; | |
| 502 const char *path = cpe->name(); | |
| 503 if (os::stat(path, &st) != 0) { | |
| 504 fail_continue("Unable to open jar file %s.", path); | |
| 505 return false; | |
| 506 } | |
| 507 if (_header._jar[num_jars_now]._timestamp != st.st_mtime || | |
| 508 _header._jar[num_jars_now]._filesize != st.st_size) { | |
| 509 fail_continue("A jar file is not the one used while building" | |
| 510 " the shared archive file."); | |
| 511 return false; | |
| 512 } | |
| 513 } | |
| 514 ++num_jars_now; | |
| 515 } else { | |
| 516 | |
| 517 // If directories appear in boot classpath, they must be empty to | |
| 518 // avoid having to verify each individual class file. | |
| 519 const char* name = ((ClassPathDirEntry*)cpe)->name(); | |
| 520 if (!os::dir_is_empty(name)) { | |
| 521 fail_continue("Boot classpath directory %s is not empty.", name); | |
| 522 return false; | |
| 523 } | |
| 524 } | |
| 525 } | |
| 526 if (num_jars_now < _header._num_jars) { | |
| 527 fail_continue("The number of jar files in the boot classpath is" | |
| 528 " less than the number the shared archive was created with."); | |
| 529 return false; | |
| 530 } | |
| 531 | |
| 532 return true; | |
| 533 } | |
| 534 | |
| 535 // The following method is provided to see whether a given pointer | |
| 536 // falls in the mapped shared space. | |
| 537 // Param: | |
| 538 // p, The given pointer | |
| 539 // Return: | |
| 540 // True if the p is within the mapped shared space, otherwise, false. | |
| 541 bool FileMapInfo::is_in_shared_space(const void* p) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
1980
diff
changeset
|
542 for (int i = 0; i < MetaspaceShared::n_regions; i++) { |
| 0 | 543 if (p >= _header._space[i]._base && |
| 544 p < _header._space[i]._base + _header._space[i]._used) { | |
| 545 return true; | |
| 546 } | |
| 547 } | |
| 548 | |
| 549 return false; | |
| 550 } | |
|
11056
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
551 |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
552 void FileMapInfo::print_shared_spaces() { |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
553 gclog_or_tty->print_cr("Shared Spaces:"); |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
554 for (int i = 0; i < MetaspaceShared::n_regions; i++) { |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
555 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
556 gclog_or_tty->print(" %s " INTPTR_FORMAT "-" INTPTR_FORMAT, |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
557 shared_region_name[i], |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
558 si->_base, si->_base + si->_used); |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
559 } |
|
221df7e37535
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
10183
diff
changeset
|
560 } |
|
12056
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
561 |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
562 // Unmap mapped regions of shared space. |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
563 void FileMapInfo::stop_sharing_and_unmap(const char* msg) { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
564 FileMapInfo *map_info = FileMapInfo::current_info(); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
565 if (map_info) { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
566 map_info->fail_continue(msg); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
567 for (int i = 0; i < MetaspaceShared::n_regions; i++) { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
568 if (map_info->_header._space[i]._base != NULL) { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
569 map_info->unmap_region(i); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
570 map_info->_header._space[i]._base = NULL; |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
571 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
572 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
573 } else if (DumpSharedSpaces) { |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
574 fail_stop(msg, NULL); |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
575 } |
|
740e263c80c6
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
11056
diff
changeset
|
576 } |