author | iklam |
Wed, 02 Aug 2017 18:06:38 -0700 | |
changeset 46746 | ea379ebb9447 |
parent 46742 | 24ec8a039c90 |
child 46810 | 7dad333205cd |
permissions | -rw-r--r-- |
1 | 1 |
/* |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
2 |
* Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. |
1 | 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 |
* |
|
5547
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2131
diff
changeset
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2131
diff
changeset
|
20 |
* or visit www.oracle.com if you need additional information or have any |
f4b087cbb361
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
2131
diff
changeset
|
21 |
* questions. |
1 | 22 |
* |
23 |
*/ |
|
24 |
||
7397 | 25 |
#include "precompiled.hpp" |
26 |
#include "classfile/classLoader.hpp" |
|
34659
3a7071043457
8143615: compactHashtable.hpp includes .inline.hpp file
iklam
parents:
33628
diff
changeset
|
27 |
#include "classfile/compactHashtable.inline.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
28 |
#include "classfile/sharedClassUtil.hpp" |
46742 | 29 |
#include "classfile/stringTable.hpp" |
7397 | 30 |
#include "classfile/symbolTable.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
31 |
#include "classfile/systemDictionaryShared.hpp" |
14577
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
32 |
#include "classfile/altHashing.hpp" |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
33 |
#if INCLUDE_ALL_GCS |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
34 |
#include "gc/g1/g1CollectedHeap.hpp" |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
35 |
#endif |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
36 |
#include "logging/log.hpp" |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46630
diff
changeset
|
37 |
#include "logging/logStream.hpp" |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
38 |
#include "logging/logMessage.hpp" |
7397 | 39 |
#include "memory/filemap.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
40 |
#include "memory/metadataFactory.hpp" |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
41 |
#include "memory/metaspaceClosure.hpp" |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
42 |
#include "memory/metaspaceShared.hpp" |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
43 |
#include "memory/oopFactory.hpp" |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
44 |
#include "oops/objArrayOop.hpp" |
46560
388aa8d67c80
8181449: Fix debug.hpp / globalDefinitions.hpp dependency inversion
kbarrett
parents:
46522
diff
changeset
|
45 |
#include "prims/jvm.h" |
31332
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
46 |
#include "prims/jvmtiExport.hpp" |
7397 | 47 |
#include "runtime/arguments.hpp" |
48 |
#include "runtime/java.hpp" |
|
49 |
#include "runtime/os.hpp" |
|
25715
d5a8dbdc5150
8049325: Introduce and clean up umbrella headers for the files in the cpu subdirectories.
goetz
parents:
24424
diff
changeset
|
50 |
#include "runtime/vm_version.hpp" |
14120
7d298141c258
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
13728
diff
changeset
|
51 |
#include "services/memTracker.hpp" |
46625 | 52 |
#include "utilities/align.hpp" |
7397 | 53 |
#include "utilities/defaultStream.hpp" |
54 |
||
1 | 55 |
# include <sys/stat.h> |
56 |
# include <errno.h> |
|
57 |
||
58 |
#ifndef O_BINARY // if defined (Win32) use binary files. |
|
59 |
#define O_BINARY 0 // otherwise do nothing. |
|
60 |
#endif |
|
61 |
||
62 |
extern address JVM_FunctionAtStart(); |
|
63 |
extern address JVM_FunctionAtEnd(); |
|
64 |
||
2131 | 65 |
// Complain and stop. All error conditions occurring during the writing of |
1 | 66 |
// an archive file should stop the process. Unrecoverable errors during |
67 |
// the reading of the archive file should stop the process. |
|
68 |
||
69 |
static void fail(const char *msg, va_list ap) { |
|
70 |
// This occurs very early during initialization: tty is not initialized. |
|
71 |
jio_fprintf(defaultStream::error_stream(), |
|
2131 | 72 |
"An error has occurred while processing the" |
1 | 73 |
" shared archive file.\n"); |
74 |
jio_vfprintf(defaultStream::error_stream(), msg, ap); |
|
75 |
jio_fprintf(defaultStream::error_stream(), "\n"); |
|
19707
fecaabc8e462
8023381: VM fails to initialize in runtime/CDSCompressedKPtrs/XShareAuto.java runtime/SharedArchiveFile/CdsSameObjectAlignment.java
hseigel
parents:
19319
diff
changeset
|
76 |
// Do not change the text of the below message because some tests check for it. |
1 | 77 |
vm_exit_during_initialization("Unable to use shared archive.", NULL); |
78 |
} |
|
79 |
||
80 |
||
81 |
void FileMapInfo::fail_stop(const char *msg, ...) { |
|
82 |
va_list ap; |
|
83 |
va_start(ap, msg); |
|
84 |
fail(msg, ap); // Never returns. |
|
85 |
va_end(ap); // for completeness. |
|
86 |
} |
|
87 |
||
88 |
||
89 |
// Complain and continue. Recoverable errors during the reading of the |
|
90 |
// archive file may continue (with sharing disabled). |
|
91 |
// |
|
92 |
// If we continue, then disable shared spaces and close the file. |
|
93 |
||
94 |
void FileMapInfo::fail_continue(const char *msg, ...) { |
|
95 |
va_list ap; |
|
96 |
va_start(ap, msg); |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
97 |
MetaspaceShared::set_archive_loading_failed(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
98 |
if (PrintSharedArchiveAndExit && _validating_classpath_entry_table) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
99 |
// If we are doing PrintSharedArchiveAndExit and some of the classpath entries |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
100 |
// do not validate, we can still continue "limping" to validate the remaining |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
101 |
// entries. No need to quit. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
102 |
tty->print("["); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
103 |
tty->vprint(msg, ap); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
104 |
tty->print_cr("]"); |
23186
9396c6fb571b
8033990: Add message to verbose output to indicate when JVM was unable to use shared archive (with -Xshare:auto)
mseledtsov
parents:
19707
diff
changeset
|
105 |
} else { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
106 |
if (RequireSharedSpaces) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
107 |
fail(msg, ap); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
108 |
} else { |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
109 |
if (log_is_enabled(Info, cds)) { |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
110 |
ResourceMark rm; |
46701
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46630
diff
changeset
|
111 |
LogStream ls(Log(cds)::info()); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46630
diff
changeset
|
112 |
ls.print("UseSharedSpaces: "); |
f559541c0daa
8181917: Refactor UL LogStreams to avoid using resource area
stuefe
parents:
46630
diff
changeset
|
113 |
ls.vprint_cr(msg, ap); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
114 |
} |
23186
9396c6fb571b
8033990: Add message to verbose output to indicate when JVM was unable to use shared archive (with -Xshare:auto)
mseledtsov
parents:
19707
diff
changeset
|
115 |
} |
28017
84009002b566
8066670: PrintSharedArchiveAndExit does not exit the VM when the archive is invalid
iklam
parents:
27880
diff
changeset
|
116 |
UseSharedSpaces = false; |
84009002b566
8066670: PrintSharedArchiveAndExit does not exit the VM when the archive is invalid
iklam
parents:
27880
diff
changeset
|
117 |
assert(current_info() != NULL, "singleton must be registered"); |
84009002b566
8066670: PrintSharedArchiveAndExit does not exit the VM when the archive is invalid
iklam
parents:
27880
diff
changeset
|
118 |
current_info()->close(); |
1 | 119 |
} |
120 |
va_end(ap); |
|
121 |
} |
|
122 |
||
14577
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
123 |
// Fill in the fileMapInfo structure with data about this VM instance. |
1 | 124 |
|
14577
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
125 |
// This method copies the vm version info into header_version. If the version is too |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
126 |
// long then a truncated version, which has a hash code appended to it, is copied. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
127 |
// |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
128 |
// Using a template enables this method to verify that header_version is an array of |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
129 |
// length JVM_IDENT_MAX. This ensures that the code that writes to the CDS file and |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
130 |
// the code that reads the CDS file will both use the same size buffer. Hence, will |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
131 |
// use identical truncation. This is necessary for matching of truncated versions. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
132 |
template <int N> static void get_header_version(char (&header_version) [N]) { |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
133 |
assert(N == JVM_IDENT_MAX, "Bad header_version size"); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
134 |
|
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
135 |
const char *vm_version = VM_Version::internal_vm_info_string(); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
136 |
const int version_len = (int)strlen(vm_version); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
137 |
|
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
138 |
if (version_len < (JVM_IDENT_MAX-1)) { |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
139 |
strcpy(header_version, vm_version); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
140 |
|
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
141 |
} else { |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
142 |
// Get the hash value. Use a static seed because the hash needs to return the same |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
143 |
// value over multiple jvm invocations. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
144 |
unsigned int hash = AltHashing::murmur3_32(8191, (const jbyte*)vm_version, version_len); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
145 |
|
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
146 |
// Truncate the ident, saving room for the 8 hex character hash value. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
147 |
strncpy(header_version, vm_version, JVM_IDENT_MAX-9); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
148 |
|
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
149 |
// Append the hash code as eight hex digits. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
150 |
sprintf(&header_version[JVM_IDENT_MAX-9], "%08x", hash); |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
151 |
header_version[JVM_IDENT_MAX-1] = 0; // Null terminate. |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
152 |
} |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
153 |
} |
1 | 154 |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
155 |
FileMapInfo::FileMapInfo() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
156 |
assert(_current_info == NULL, "must be singleton"); // not thread safe |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
157 |
_current_info = this; |
46630
75aa3e39d02c
8182299: Enable disabled clang warnings, build on OSX 10 + Xcode 8
jwilhelm
parents:
46625
diff
changeset
|
158 |
memset((void*)this, 0, sizeof(FileMapInfo)); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
159 |
_file_offset = 0; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
160 |
_file_open = false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
161 |
_header = SharedClassUtil::allocate_file_map_header(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
162 |
_header->_version = _invalid_version; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
163 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
164 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
165 |
FileMapInfo::~FileMapInfo() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
166 |
assert(_current_info == this, "must be singleton"); // not thread safe |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
167 |
_current_info = NULL; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
168 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
169 |
|
1 | 170 |
void FileMapInfo::populate_header(size_t alignment) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
171 |
_header->populate(this, alignment); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
172 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
173 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
174 |
size_t FileMapInfo::FileMapHeader::data_size() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
175 |
return SharedClassUtil::file_map_header_size() - sizeof(FileMapInfo::FileMapHeaderBase); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
176 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
177 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
178 |
void FileMapInfo::FileMapHeader::populate(FileMapInfo* mapinfo, size_t alignment) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
179 |
_magic = 0xf00baba2; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
180 |
_version = _current_version; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
181 |
_alignment = alignment; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
182 |
_obj_alignment = ObjectAlignmentInBytes; |
33628 | 183 |
_compact_strings = CompactStrings; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
184 |
_narrow_oop_mode = Universe::narrow_oop_mode(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
185 |
_narrow_oop_shift = Universe::narrow_oop_shift(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
186 |
_max_heap_size = MaxHeapSize; |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
187 |
_narrow_klass_base = Universe::narrow_klass_base(); |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
188 |
_narrow_klass_shift = Universe::narrow_klass_shift(); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
189 |
_classpath_entry_table_size = mapinfo->_classpath_entry_table_size; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
190 |
_classpath_entry_table = mapinfo->_classpath_entry_table; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
191 |
_classpath_entry_size = mapinfo->_classpath_entry_size; |
1 | 192 |
|
193 |
// The following fields are for sanity checks for whether this archive |
|
194 |
// will function correctly with this JVM and the bootclasspath it's |
|
195 |
// invoked with. |
|
196 |
||
197 |
// JVM version string ... changes on each build. |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
198 |
get_header_version(_jvm_ident); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
199 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
200 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
201 |
void SharedClassPathEntry::init(const char* name, TRAPS) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
202 |
_timestamp = 0; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
203 |
_filesize = 0; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
204 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
205 |
struct stat st; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
206 |
if (os::stat(name, &st) == 0) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
207 |
if ((st.st_mode & S_IFMT) == S_IFDIR) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
208 |
if (!os::dir_is_empty(name)) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
209 |
ClassLoader::exit_with_path_failure( |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
210 |
"Cannot have non-empty directory in archived classpaths", name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
211 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
212 |
_is_dir = true; |
40013 | 213 |
} else { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
214 |
_is_dir = false; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
215 |
_timestamp = st.st_mtime; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
216 |
_filesize = st.st_size; |
40013 | 217 |
} |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
218 |
} else { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
219 |
// The file/dir must exist, or it would not have been added |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
220 |
// into ClassLoader::classpath_entry(). |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
221 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
222 |
// If we can't access a jar file in the boot path, then we can't |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
223 |
// make assumptions about where classes get loaded from. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
224 |
FileMapInfo::fail_stop("Unable to open file %s.", name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
225 |
} |
40013 | 226 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
227 |
size_t len = strlen(name) + 1; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
228 |
_name = MetadataFactory::new_array<char>(ClassLoaderData::the_null_class_loader_data(), (int)len, THREAD); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
229 |
strcpy(_name->data(), name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
230 |
} |
1 | 231 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
232 |
bool SharedClassPathEntry::validate() { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
233 |
struct stat st; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
234 |
const char* name = this->name(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
235 |
bool ok = true; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
236 |
log_info(class, path)("checking shared classpath entry: %s", name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
237 |
if (os::stat(name, &st) != 0) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
238 |
FileMapInfo::fail_continue("Required classpath entry does not exist: %s", name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
239 |
ok = false; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
240 |
} else if (is_dir()) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
241 |
if (!os::dir_is_empty(name)) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
242 |
FileMapInfo::fail_continue("directory is not empty: %s", name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
243 |
ok = false; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
244 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
245 |
} else if (is_jar_or_bootimage()) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
246 |
if (_timestamp != st.st_mtime || |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
247 |
_filesize != st.st_size) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
248 |
ok = false; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
249 |
if (PrintSharedArchiveAndExit) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
250 |
FileMapInfo::fail_continue(_timestamp != st.st_mtime ? |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
251 |
"Timestamp mismatch" : |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
252 |
"File size mismatch"); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
253 |
} else { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
254 |
FileMapInfo::fail_continue("A jar/jimage file is not the one used while building" |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
255 |
" the shared archive file: %s", name); |
1 | 256 |
} |
257 |
} |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
258 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
259 |
return ok; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
260 |
} |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
261 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
262 |
void SharedClassPathEntry::metaspace_pointers_do(MetaspaceClosure* it) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
263 |
it->push(&_name); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
264 |
it->push(&_manifest); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
265 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
266 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
267 |
void FileMapInfo::allocate_classpath_entry_table() { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
268 |
Thread* THREAD = Thread::current(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
269 |
ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
270 |
size_t entry_size = SharedClassUtil::shared_class_path_entry_size(); // assert ( should be 8 byte aligned??) |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
271 |
int num_entries = ClassLoader::number_of_classpath_entries(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
272 |
size_t bytes = entry_size * num_entries; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
273 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
274 |
_classpath_entry_table = MetadataFactory::new_array<u8>(loader_data, (int)(bytes + 7 / 8), THREAD); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
275 |
_classpath_entry_table_size = num_entries; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
276 |
_classpath_entry_size = entry_size; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
277 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
278 |
assert(ClassLoader::get_jrt_entry() != NULL, |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
279 |
"No modular java runtime image present when allocating the CDS classpath entry table"); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
280 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
281 |
for (int i=0; i<num_entries; i++) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
282 |
ClassPathEntry *cpe = ClassLoader::classpath_entry(i); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
283 |
const char* type = ((i == 0) ? "jrt" : (cpe->is_jar_file() ? "jar" : "dir")); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
284 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
285 |
log_info(class, path)("add main shared path (%s) %s", type, cpe->name()); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
286 |
SharedClassPathEntry* ent = shared_classpath(i); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
287 |
ent->init(cpe->name(), THREAD); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
288 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
289 |
if (i > 0) { // No need to do jimage. |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
290 |
EXCEPTION_MARK; // The following call should never throw, but would exit VM on error. |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
291 |
SharedClassUtil::update_shared_classpath(cpe, ent, THREAD); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
292 |
} |
1 | 293 |
} |
294 |
} |
|
295 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
296 |
bool FileMapInfo::validate_classpath_entry_table() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
297 |
_validating_classpath_entry_table = true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
298 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
299 |
int count = _header->_classpath_entry_table_size; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
300 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
301 |
_classpath_entry_table = _header->_classpath_entry_table; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
302 |
_classpath_entry_size = _header->_classpath_entry_size; |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
303 |
_classpath_entry_table_size = _header->_classpath_entry_table_size; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
304 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
305 |
for (int i=0; i<count; i++) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
306 |
if (shared_classpath(i)->validate()) { |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38108
diff
changeset
|
307 |
log_info(class, path)("ok"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
308 |
} else if (!PrintSharedArchiveAndExit) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
309 |
_validating_classpath_entry_table = false; |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
310 |
_classpath_entry_table = NULL; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
311 |
_classpath_entry_table_size = 0; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
312 |
return false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
313 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
314 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
315 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
316 |
_validating_classpath_entry_table = false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
317 |
return true; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
318 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
319 |
|
1 | 320 |
|
321 |
// Read the FileMapInfo information from the file. |
|
322 |
||
323 |
bool FileMapInfo::init_from_file(int fd) { |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
324 |
size_t sz = _header->data_size(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
325 |
char* addr = _header->data(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
326 |
size_t n = os::read(fd, addr, (unsigned int)sz); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
327 |
if (n != sz) { |
1 | 328 |
fail_continue("Unable to read the file header."); |
329 |
return false; |
|
330 |
} |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
331 |
if (_header->_version != current_version()) { |
1 | 332 |
fail_continue("The shared archive file has the wrong version."); |
333 |
return false; |
|
334 |
} |
|
335 |
_file_offset = (long)n; |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
336 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
337 |
size_t info_size = _header->_paths_misc_info_size; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
338 |
_paths_misc_info = NEW_C_HEAP_ARRAY_RETURN_NULL(char, info_size, mtClass); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
339 |
if (_paths_misc_info == NULL) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
340 |
fail_continue("Unable to read the file header."); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
341 |
return false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
342 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
343 |
n = os::read(fd, _paths_misc_info, (unsigned int)info_size); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
344 |
if (n != info_size) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
345 |
fail_continue("Unable to read the shared path info header."); |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27025
diff
changeset
|
346 |
FREE_C_HEAP_ARRAY(char, _paths_misc_info); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
347 |
_paths_misc_info = NULL; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
348 |
return false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
349 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
350 |
|
27025 | 351 |
size_t len = lseek(fd, 0, SEEK_END); |
352 |
struct FileMapInfo::FileMapHeader::space_info* si = |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
353 |
&_header->_space[MetaspaceShared::last_valid_region]; |
27025 | 354 |
if (si->_file_offset >= len || len - si->_file_offset < si->_used) { |
355 |
fail_continue("The shared archive file has been truncated."); |
|
356 |
return false; |
|
357 |
} |
|
358 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
359 |
_file_offset += (long)n; |
1 | 360 |
return true; |
361 |
} |
|
362 |
||
363 |
||
364 |
// Read the FileMapInfo information from the file. |
|
365 |
bool FileMapInfo::open_for_read() { |
|
366 |
_full_path = Arguments::GetSharedArchivePath(); |
|
367 |
int fd = open(_full_path, O_RDONLY | O_BINARY, 0); |
|
368 |
if (fd < 0) { |
|
369 |
if (errno == ENOENT) { |
|
370 |
// Not locating the shared archive is ok. |
|
371 |
fail_continue("Specified shared archive not found."); |
|
372 |
} else { |
|
373 |
fail_continue("Failed to open shared archive file (%s).", |
|
37113 | 374 |
os::strerror(errno)); |
1 | 375 |
} |
376 |
return false; |
|
377 |
} |
|
378 |
||
379 |
_fd = fd; |
|
380 |
_file_open = true; |
|
381 |
return true; |
|
382 |
} |
|
383 |
||
384 |
||
385 |
// Write the FileMapInfo information to the file. |
|
386 |
||
387 |
void FileMapInfo::open_for_write() { |
|
388 |
_full_path = Arguments::GetSharedArchivePath(); |
|
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
389 |
if (log_is_enabled(Info, cds)) { |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
390 |
ResourceMark rm; |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
391 |
LogMessage(cds) msg; |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
392 |
stringStream info_stream; |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
393 |
info_stream.print_cr("Dumping shared data to file: "); |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
394 |
info_stream.print_cr(" %s", _full_path); |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
395 |
msg.info("%s", info_stream.as_string()); |
1 | 396 |
} |
397 |
||
15461
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
398 |
#ifdef _WINDOWS // On Windows, need WRITE permission to remove the file. |
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
399 |
chmod(_full_path, _S_IREAD | _S_IWRITE); |
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
400 |
#endif |
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
401 |
|
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
402 |
// Use remove() to delete the existing file because, on Unix, this will |
e3acbfdabafa
7197672: There are issues with shared data on windows
hseigel
parents:
15101
diff
changeset
|
403 |
// allow processes that have it open continued access to the file. |
1 | 404 |
remove(_full_path); |
405 |
int fd = open(_full_path, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0444); |
|
406 |
if (fd < 0) { |
|
28950
693ae3d5e1ff
8072694: Need errno info when CDS archive creation fails
hseigel
parents:
28023
diff
changeset
|
407 |
fail_stop("Unable to create shared archive file %s: (%s).", _full_path, |
37113 | 408 |
os::strerror(errno)); |
1 | 409 |
} |
410 |
_fd = fd; |
|
411 |
_file_offset = 0; |
|
412 |
_file_open = true; |
|
413 |
} |
|
414 |
||
415 |
||
416 |
// Write the header to the file, seek to the next allocation boundary. |
|
417 |
||
418 |
void FileMapInfo::write_header() { |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
419 |
int info_size = ClassLoader::get_shared_paths_misc_info_size(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
420 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
421 |
_header->_paths_misc_info_size = info_size; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
422 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
423 |
align_file_position(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
424 |
size_t sz = _header->data_size(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
425 |
char* addr = _header->data(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
426 |
write_bytes(addr, (int)sz); // skip the C++ vtable |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
427 |
write_bytes(ClassLoader::get_shared_paths_misc_info(), info_size); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
428 |
align_file_position(); |
1 | 429 |
} |
430 |
||
431 |
||
432 |
// Dump region to file. |
|
433 |
||
434 |
void FileMapInfo::write_region(int region, char* base, size_t size, |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
435 |
bool read_only, bool allow_exec) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
436 |
struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[region]; |
1 | 437 |
|
438 |
if (_file_open) { |
|
439 |
guarantee(si->_file_offset == _file_offset, "file offset mismatch."); |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
440 |
log_info(cds)("Shared file region %d: " SIZE_FORMAT_HEX_W(08) |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
441 |
" bytes, addr " INTPTR_FORMAT " file offset " SIZE_FORMAT_HEX_W(08), |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
442 |
region, size, p2i(base), _file_offset); |
1 | 443 |
} else { |
444 |
si->_file_offset = _file_offset; |
|
445 |
} |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
446 |
if (MetaspaceShared::is_string_region(region)) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
447 |
assert((base - (char*)Universe::narrow_oop_base()) % HeapWordSize == 0, "Sanity"); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
448 |
if (base != NULL) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
449 |
si->_addr._offset = (intx)oopDesc::encode_heap_oop_not_null((oop)base); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
450 |
} else { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
451 |
si->_addr._offset = 0; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
452 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
453 |
} else { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
454 |
si->_addr._base = base; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
455 |
} |
1 | 456 |
si->_used = size; |
457 |
si->_read_only = read_only; |
|
458 |
si->_allow_exec = allow_exec; |
|
27025 | 459 |
si->_crc = ClassLoader::crc32(0, base, (jint)size); |
1 | 460 |
write_bytes_aligned(base, (int)size); |
461 |
} |
|
462 |
||
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
463 |
// Write the string space. The string space contains one or multiple GC(G1) regions. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
464 |
// When the total string space size is smaller than one GC region of the dump time, |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
465 |
// only one string region is used for shared strings. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
466 |
// |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
467 |
// If the total string space size is bigger than one GC region, there would be more |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
468 |
// than one GC regions allocated for shared strings. The first/bottom GC region might |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
469 |
// be a partial GC region with the empty portion at the higher address within that region. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
470 |
// The non-empty portion of the first region is written into the archive as one string |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
471 |
// region. The rest are consecutive full GC regions if they exist, which can be written |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
472 |
// out in one chunk as another string region. |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
473 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
474 |
// Here's the mapping from (GrowableArray<MemRegion> *regions) -> (metaspace string regions). |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
475 |
// + We have 1 or more heap regions: r0, r1, r2 ..... rn |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
476 |
// + We have 2 metaspace string regions: s0 and s1 |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
477 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
478 |
// If there's a single heap region (r0), then s0 == r0, and s1 is empty. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
479 |
// Otherwise: |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
480 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
481 |
// "X" represented space that's occupied by heap objects. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
482 |
// "_" represented unused spaced in the heap region. |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
483 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
484 |
// |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
485 |
// |r0 | r1 | r2 | ...... | rn | |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
486 |
// |XXXXXX|__ |XXXXX|XXXX|XXXXXXXX|XXXX| |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
487 |
// |<-s0->| |<- s1 ----------------->| |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
488 |
// ^^^ |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
489 |
// | |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
490 |
// +-- unmapped space |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
491 |
void FileMapInfo::write_string_regions(GrowableArray<MemRegion> *regions, |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
492 |
char** st0_start, char** st0_top, char** st0_end, |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
493 |
char** st1_start, char** st1_top, char** st1_end) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
494 |
*st0_start = *st0_top = *st0_end = NULL; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
495 |
*st1_start = *st1_top = *st1_end = NULL; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
496 |
|
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
497 |
assert(MetaspaceShared::max_strings == 2, "this loop doesn't work for any other value"); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
498 |
for (int i = MetaspaceShared::first_string; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
499 |
i < MetaspaceShared::first_string + MetaspaceShared::max_strings; i++) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
500 |
char* start = NULL; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
501 |
size_t size = 0; |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
502 |
int len = regions->length(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
503 |
if (len > 0) { |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
504 |
if (i == MetaspaceShared::first_string) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
505 |
MemRegion first = regions->first(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
506 |
start = (char*)first.start(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
507 |
size = first.byte_size(); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
508 |
*st0_start = start; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
509 |
*st0_top = start + size; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
510 |
if (len > 1) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
511 |
*st0_end = (char*)regions->at(1).start(); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
512 |
} else { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
513 |
*st0_end = start + size; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
514 |
} |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
515 |
} else { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
516 |
assert(i == MetaspaceShared::first_string + 1, "must be"); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
517 |
if (len > 1) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
518 |
start = (char*)regions->at(1).start(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
519 |
size = (char*)regions->at(len - 1).end() - start; |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
520 |
*st1_start = start; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
521 |
*st1_top = start + size; |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
522 |
*st1_end = start + size; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
523 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
524 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
525 |
} |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
526 |
log_info(cds)("String region %d " INTPTR_FORMAT " - " INTPTR_FORMAT " = " SIZE_FORMAT_W(8) " bytes", |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
527 |
i, p2i(start), p2i(start + size), size); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
528 |
write_region(i, start, size, false, false); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
529 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
530 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
531 |
|
1 | 532 |
|
533 |
// Dump bytes to file -- at the current file position. |
|
534 |
||
535 |
void FileMapInfo::write_bytes(const void* buffer, int nbytes) { |
|
536 |
if (_file_open) { |
|
537 |
int n = ::write(_fd, buffer, nbytes); |
|
538 |
if (n != nbytes) { |
|
539 |
// It is dangerous to leave the corrupted shared archive file around, |
|
540 |
// close and remove the file. See bug 6372906. |
|
541 |
close(); |
|
542 |
remove(_full_path); |
|
26296 | 543 |
fail_stop("Unable to write to shared archive file."); |
1 | 544 |
} |
545 |
} |
|
546 |
_file_offset += nbytes; |
|
547 |
} |
|
548 |
||
549 |
||
550 |
// Align file position to an allocation unit boundary. |
|
551 |
||
552 |
void FileMapInfo::align_file_position() { |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46560
diff
changeset
|
553 |
size_t new_file_offset = align_up(_file_offset, |
27025 | 554 |
os::vm_allocation_granularity()); |
1 | 555 |
if (new_file_offset != _file_offset) { |
556 |
_file_offset = new_file_offset; |
|
557 |
if (_file_open) { |
|
558 |
// Seek one byte back from the target and write a byte to insure |
|
559 |
// that the written file is the correct length. |
|
560 |
_file_offset -= 1; |
|
27025 | 561 |
if (lseek(_fd, (long)_file_offset, SEEK_SET) < 0) { |
26296 | 562 |
fail_stop("Unable to seek."); |
1 | 563 |
} |
564 |
char zero = 0; |
|
565 |
write_bytes(&zero, 1); |
|
566 |
} |
|
567 |
} |
|
568 |
} |
|
569 |
||
570 |
||
571 |
// Dump bytes to file -- at the current file position. |
|
572 |
||
573 |
void FileMapInfo::write_bytes_aligned(const void* buffer, int nbytes) { |
|
574 |
align_file_position(); |
|
575 |
write_bytes(buffer, nbytes); |
|
576 |
align_file_position(); |
|
577 |
} |
|
578 |
||
579 |
||
580 |
// Close the shared archive file. This does NOT unmap mapped regions. |
|
581 |
||
582 |
void FileMapInfo::close() { |
|
583 |
if (_file_open) { |
|
584 |
if (::close(_fd) < 0) { |
|
585 |
fail_stop("Unable to close the shared archive file."); |
|
586 |
} |
|
587 |
_file_open = false; |
|
588 |
_fd = -1; |
|
589 |
} |
|
590 |
} |
|
591 |
||
592 |
||
593 |
// JVM/TI RedefineClasses() support: |
|
594 |
// Remap the shared readonly space to shared readwrite, private. |
|
595 |
bool FileMapInfo::remap_shared_readonly_as_readwrite() { |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
596 |
int idx = MetaspaceShared::ro; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
597 |
struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[idx]; |
1 | 598 |
if (!si->_read_only) { |
599 |
// the space is already readwrite so we are done |
|
600 |
return true; |
|
601 |
} |
|
602 |
size_t used = si->_used; |
|
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46560
diff
changeset
|
603 |
size_t size = align_up(used, os::vm_allocation_granularity()); |
1 | 604 |
if (!open_for_read()) { |
605 |
return false; |
|
606 |
} |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
607 |
char *addr = _header->region_addr(idx); |
1 | 608 |
char *base = os::remap_memory(_fd, _full_path, si->_file_offset, |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
609 |
addr, size, false /* !read_only */, |
1 | 610 |
si->_allow_exec); |
611 |
close(); |
|
612 |
if (base == NULL) { |
|
613 |
fail_continue("Unable to remap shared readonly space (errno=%d).", errno); |
|
614 |
return false; |
|
615 |
} |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
616 |
if (base != addr) { |
1 | 617 |
fail_continue("Unable to remap shared readonly space at required address."); |
618 |
return false; |
|
619 |
} |
|
620 |
si->_read_only = false; |
|
621 |
return true; |
|
622 |
} |
|
623 |
||
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
624 |
// Map the whole region at once, assumed to be allocated contiguously. |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
625 |
ReservedSpace FileMapInfo::reserve_shared_memory() { |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
626 |
char* requested_addr = _header->region_addr(0); |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
627 |
size_t size = FileMapInfo::core_spaces_size(); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
628 |
|
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
629 |
// Reserve the space first, then map otherwise map will go right over some |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
630 |
// other reserved memory (like the code cache). |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
631 |
ReservedSpace rs(size, os::vm_allocation_granularity(), false, requested_addr); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
632 |
if (!rs.is_reserved()) { |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32589
diff
changeset
|
633 |
fail_continue("Unable to reserve shared space at required address " |
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32589
diff
changeset
|
634 |
INTPTR_FORMAT, p2i(requested_addr)); |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
635 |
return rs; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
636 |
} |
14120
7d298141c258
7199092: NMT: NMT needs to deal overlapped virtual memory ranges
zgu
parents:
13728
diff
changeset
|
637 |
// the reserved virtual memory is for mapping class data sharing archive |
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
638 |
MemTracker::record_virtual_memory_type((address)rs.base(), mtClassShared); |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
639 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
640 |
return rs; |
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
641 |
} |
1 | 642 |
|
643 |
// Memory map a region in the address space. |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
644 |
static const char* shared_region_name[] = { "ReadOnly", "ReadWrite", "MiscData", "MiscCode", |
41182 | 645 |
"String1", "String2", "OptionalData" }; |
1 | 646 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
647 |
char* FileMapInfo::map_region(int i) { |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
648 |
assert(!MetaspaceShared::is_string_region(i), "sanity"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
649 |
struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[i]; |
1 | 650 |
size_t used = si->_used; |
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
651 |
size_t alignment = os::vm_allocation_granularity(); |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46560
diff
changeset
|
652 |
size_t size = align_up(used, alignment); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
653 |
char *requested_addr = _header->region_addr(i); |
31332
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
654 |
|
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
655 |
// If a tool agent is in use (debugging enabled), we must map the address space RW |
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
656 |
if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space()) { |
31375
aa5ecd9a5716
8087153: EXCEPTION_ACCESS_VIOLATION when CDS RO section vanished on win32
cjplummer
parents:
31364
diff
changeset
|
657 |
si->_read_only = false; |
31332
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
658 |
} |
dc17890f352d
8054386: Allow Java debugging when CDS is enabled
cjplummer
parents:
28950
diff
changeset
|
659 |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
660 |
// map the contents of the CDS archive in this memory |
1 | 661 |
char *base = os::map_memory(_fd, _full_path, si->_file_offset, |
31375
aa5ecd9a5716
8087153: EXCEPTION_ACCESS_VIOLATION when CDS RO section vanished on win32
cjplummer
parents:
31364
diff
changeset
|
662 |
requested_addr, size, si->_read_only, |
1 | 663 |
si->_allow_exec); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
664 |
if (base == NULL || base != requested_addr) { |
26296 | 665 |
fail_continue("Unable to map %s shared space at required address.", shared_region_name[i]); |
1 | 666 |
return NULL; |
667 |
} |
|
15100
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
668 |
#ifdef _WINDOWS |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
669 |
// This call is Windows-only because the memory_type gets recorded for the other platforms |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
670 |
// in method FileMapInfo::reserve_shared_memory(), which is not called on Windows. |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
671 |
MemTracker::record_virtual_memory_type((address)base, mtClassShared); |
0ae85ac7c8b0
8003705: CDS failed on Windows: can not map in the CDS.
hseigel
parents:
14577
diff
changeset
|
672 |
#endif |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
673 |
|
1 | 674 |
return base; |
675 |
} |
|
676 |
||
31360
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
677 |
static MemRegion *string_ranges = NULL; |
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
678 |
static int num_ranges = 0; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
679 |
bool FileMapInfo::map_string_regions() { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
680 |
#if INCLUDE_ALL_GCS |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
681 |
if (UseG1GC && UseCompressedOops && UseCompressedClassPointers) { |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
682 |
// Check that all the narrow oop and klass encodings match the archive |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
683 |
if (narrow_oop_mode() != Universe::narrow_oop_mode() || |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
684 |
narrow_oop_shift() != Universe::narrow_oop_shift() || |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
685 |
narrow_klass_base() != Universe::narrow_klass_base() || |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
686 |
narrow_klass_shift() != Universe::narrow_klass_shift()) { |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
687 |
if (log_is_enabled(Info, cds) && _header->_space[MetaspaceShared::first_string]._used > 0) { |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
688 |
log_info(cds)("Shared string data from the CDS archive is being ignored. " |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
689 |
"The current CompressedOops/CompressedClassPointers encoding differs from " |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
690 |
"that archived due to heap size change. The archive was dumped using max heap " |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
691 |
"size " UINTX_FORMAT "M.", max_heap_size()/M); |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
692 |
} |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
693 |
} else { |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
694 |
string_ranges = new MemRegion[MetaspaceShared::max_strings]; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
695 |
struct FileMapInfo::FileMapHeader::space_info* si; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
696 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
697 |
for (int i = MetaspaceShared::first_string; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
698 |
i < MetaspaceShared::first_string + MetaspaceShared::max_strings; i++) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
699 |
si = &_header->_space[i]; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
700 |
size_t used = si->_used; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
701 |
if (used > 0) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
702 |
size_t size = used; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
703 |
char* requested_addr = (char*)((void*)oopDesc::decode_heap_oop_not_null( |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
704 |
(narrowOop)si->_addr._offset)); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
705 |
string_ranges[num_ranges] = MemRegion((HeapWord*)requested_addr, size / HeapWordSize); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
706 |
num_ranges ++; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
707 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
708 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
709 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
710 |
if (num_ranges == 0) { |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
711 |
StringTable::ignore_shared_strings(true); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
712 |
return true; // no shared string data |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
713 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
714 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
715 |
// Check that ranges are within the java heap |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
716 |
if (!G1CollectedHeap::heap()->check_archive_addresses(string_ranges, num_ranges)) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
717 |
fail_continue("Unable to allocate shared string space: range is not " |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
718 |
"within java heap."); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
719 |
return false; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
720 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
721 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
722 |
// allocate from java heap |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
723 |
if (!G1CollectedHeap::heap()->alloc_archive_regions(string_ranges, num_ranges)) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
724 |
fail_continue("Unable to allocate shared string space: range is " |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
725 |
"already in use."); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
726 |
return false; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
727 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
728 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
729 |
// Map the string data. No need to call MemTracker::record_virtual_memory_type() |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
730 |
// for mapped string regions as they are part of the reserved java heap, which |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
731 |
// is already recorded. |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
732 |
for (int i = 0; i < num_ranges; i++) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
733 |
si = &_header->_space[MetaspaceShared::first_string + i]; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
734 |
char* addr = (char*)string_ranges[i].start(); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
735 |
char* base = os::map_memory(_fd, _full_path, si->_file_offset, |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
736 |
addr, string_ranges[i].byte_size(), si->_read_only, |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
737 |
si->_allow_exec); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
738 |
if (base == NULL || base != addr) { |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
739 |
// dealloc the string regions from java heap |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
740 |
dealloc_string_regions(); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
741 |
fail_continue("Unable to map shared string space at required address."); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
742 |
return false; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
743 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
744 |
} |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
745 |
|
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
746 |
if (!verify_string_regions()) { |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
747 |
// dealloc the string regions from java heap |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
748 |
dealloc_string_regions(); |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
749 |
fail_continue("Shared string regions are corrupt"); |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
750 |
return false; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
751 |
} |
31362
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
752 |
|
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
753 |
// the shared string data is mapped successfully |
8957ccbb5821
8098821: Crash in system dictionary initialization with shared strings
coleenp
parents:
31345
diff
changeset
|
754 |
return true; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
755 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
756 |
} else { |
46522
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
757 |
if (log_is_enabled(Info, cds) && _header->_space[MetaspaceShared::first_string]._used > 0) { |
86b13b03a053
8176132: -XX:+PrintSharedSpaces should be converted to use Unified Logging.
rprotacio
parents:
42876
diff
changeset
|
758 |
log_info(cds)("Shared string data from the CDS archive is being ignored. UseG1GC, " |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
759 |
"UseCompressedOops and UseCompressedClassPointers are required."); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
760 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
761 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
762 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
763 |
// if we get here, the shared string data is not mapped |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
764 |
assert(string_ranges == NULL && num_ranges == 0, "sanity"); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
765 |
StringTable::ignore_shared_strings(true); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
766 |
#endif |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
767 |
return true; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
768 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
769 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
770 |
bool FileMapInfo::verify_string_regions() { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
771 |
for (int i = MetaspaceShared::first_string; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
772 |
i < MetaspaceShared::first_string + MetaspaceShared::max_strings; i++) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
773 |
if (!verify_region_checksum(i)) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
774 |
return false; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
775 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
776 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
777 |
return true; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
778 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
779 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
780 |
void FileMapInfo::fixup_string_regions() { |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
781 |
#if INCLUDE_ALL_GCS |
31360
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
782 |
// If any string regions were found, call the fill routine to make them parseable. |
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
783 |
// Note that string_ranges may be non-NULL even if no ranges were found. |
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
784 |
if (num_ranges != 0) { |
87d3a62c7e35
8098815: Assertion failure in CDS shared string archive support on Windows
iklam
parents:
31345
diff
changeset
|
785 |
assert(string_ranges != NULL, "Null string_ranges array with non-zero count"); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
786 |
G1CollectedHeap::heap()->fill_archive_regions(string_ranges, num_ranges); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
787 |
} |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
788 |
#endif |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
789 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
790 |
|
27025 | 791 |
bool FileMapInfo::verify_region_checksum(int i) { |
792 |
if (!VerifySharedSpaces) { |
|
793 |
return true; |
|
794 |
} |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
795 |
|
27025 | 796 |
size_t sz = _header->_space[i]._used; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
797 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
798 |
if (sz == 0) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
799 |
return true; // no data |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
800 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
801 |
if (MetaspaceShared::is_string_region(i) && StringTable::shared_string_ignored()) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
802 |
return true; // shared string data are not mapped |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
803 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
804 |
const char* buf = _header->region_addr(i); |
27025 | 805 |
int crc = ClassLoader::crc32(0, buf, (jint)sz); |
806 |
if (crc != _header->_space[i]._crc) { |
|
807 |
fail_continue("Checksum verification failed."); |
|
808 |
return false; |
|
809 |
} |
|
810 |
return true; |
|
811 |
} |
|
1 | 812 |
|
813 |
// Unmap a memory region in the address space. |
|
814 |
||
815 |
void FileMapInfo::unmap_region(int i) { |
|
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
816 |
assert(!MetaspaceShared::is_string_region(i), "sanity"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
817 |
struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[i]; |
1 | 818 |
size_t used = si->_used; |
46619
a3919f5e8d2b
8178499: Remove _ptr_ and _size_ infixes from align functions
stefank
parents:
46560
diff
changeset
|
819 |
size_t size = align_up(used, os::vm_allocation_granularity()); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
820 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
821 |
if (used == 0) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
822 |
return; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
823 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
824 |
|
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
825 |
char* addr = _header->region_addr(i); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
826 |
if (!os::unmap_memory(addr, size)) { |
1 | 827 |
fail_stop("Unable to unmap shared space."); |
828 |
} |
|
829 |
} |
|
830 |
||
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
831 |
// dealloc the archived string region from java heap |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
832 |
void FileMapInfo::dealloc_string_regions() { |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
833 |
#if INCLUDE_ALL_GCS |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
834 |
if (num_ranges > 0) { |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
835 |
assert(string_ranges != NULL, "Null string_ranges array with non-zero count"); |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
836 |
G1CollectedHeap::heap()->dealloc_archive_regions(string_ranges, num_ranges); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
837 |
} |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
838 |
#endif |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
839 |
} |
1 | 840 |
|
841 |
void FileMapInfo::assert_mark(bool check) { |
|
842 |
if (!check) { |
|
26296 | 843 |
fail_stop("Mark mismatch while restoring from shared file."); |
1 | 844 |
} |
845 |
} |
|
846 |
||
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
847 |
void FileMapInfo::metaspace_pointers_do(MetaspaceClosure* it) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
848 |
it->push(&_classpath_entry_table); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
849 |
for (int i=0; i<_classpath_entry_table_size; i++) { |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
850 |
shared_classpath(i)->metaspace_pointers_do(it); |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
851 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
852 |
} |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
853 |
|
1 | 854 |
|
855 |
FileMapInfo* FileMapInfo::_current_info = NULL; |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
856 |
Array<u8>* FileMapInfo::_classpath_entry_table = NULL; |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
857 |
int FileMapInfo::_classpath_entry_table_size = 0; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
858 |
size_t FileMapInfo::_classpath_entry_size = 0x1234baad; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
859 |
bool FileMapInfo::_validating_classpath_entry_table = false; |
1 | 860 |
|
861 |
// Open the shared archive file, read and validate the header |
|
862 |
// information (version, boot classpath, etc.). If initialization |
|
863 |
// fails, shared spaces are disabled and the file is closed. [See |
|
864 |
// fail_continue.] |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
865 |
// |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
866 |
// Validation of the archive is done in two steps: |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
867 |
// |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
868 |
// [1] validate_header() - done here. This checks the header, including _paths_misc_info. |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
869 |
// [2] validate_classpath_entry_table - this is done later, because the table is in the RW |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
870 |
// region of the archive, which is not mapped yet. |
1 | 871 |
bool FileMapInfo::initialize() { |
872 |
assert(UseSharedSpaces, "UseSharedSpaces expected."); |
|
873 |
||
874 |
if (!open_for_read()) { |
|
875 |
return false; |
|
876 |
} |
|
877 |
||
878 |
init_from_file(_fd); |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
879 |
if (!validate_header()) { |
1 | 880 |
return false; |
881 |
} |
|
882 |
return true; |
|
883 |
} |
|
884 |
||
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
885 |
char* FileMapInfo::FileMapHeader::region_addr(int idx) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
886 |
if (MetaspaceShared::is_string_region(idx)) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
887 |
return (char*)((void*)oopDesc::decode_heap_oop_not_null( |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
888 |
(narrowOop)_space[idx]._addr._offset)); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
889 |
} else { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
890 |
return _space[idx]._addr._base; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
891 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
892 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
893 |
|
27025 | 894 |
int FileMapInfo::FileMapHeader::compute_crc() { |
895 |
char* header = data(); |
|
896 |
// start computing from the field after _crc |
|
897 |
char* buf = (char*)&_crc + sizeof(int); |
|
898 |
size_t sz = data_size() - (buf - header); |
|
899 |
int crc = ClassLoader::crc32(0, buf, (jint)sz); |
|
900 |
return crc; |
|
901 |
} |
|
902 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
903 |
bool FileMapInfo::FileMapHeader::validate() { |
27025 | 904 |
if (VerifySharedSpaces && compute_crc() != _crc) { |
905 |
fail_continue("Header checksum verification failed."); |
|
906 |
return false; |
|
907 |
} |
|
908 |
||
40013 | 909 |
if (!Arguments::has_jimage()) { |
910 |
FileMapInfo::fail_continue("The shared archive file cannot be used with an exploded module build."); |
|
911 |
return false; |
|
912 |
} |
|
913 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
914 |
if (_version != current_version()) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
915 |
FileMapInfo::fail_continue("The shared archive file is the wrong version."); |
1 | 916 |
return false; |
917 |
} |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
918 |
if (_magic != (int)0xf00baba2) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
919 |
FileMapInfo::fail_continue("The shared archive file has a bad magic number."); |
1 | 920 |
return false; |
921 |
} |
|
14577
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
922 |
char header_version[JVM_IDENT_MAX]; |
fd68d810d86b
6924920: Class Data Sharing limit on the java version string can create failures
hseigel
parents:
14120
diff
changeset
|
923 |
get_header_version(header_version); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
924 |
if (strncmp(_jvm_ident, header_version, JVM_IDENT_MAX-1) != 0) { |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38108
diff
changeset
|
925 |
log_info(class, path)("expected: %s", header_version); |
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38108
diff
changeset
|
926 |
log_info(class, path)("actual: %s", _jvm_ident); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
927 |
FileMapInfo::fail_continue("The shared archive file was created by a different" |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
928 |
" version or build of HotSpot"); |
1 | 929 |
return false; |
930 |
} |
|
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
931 |
if (_obj_alignment != ObjectAlignmentInBytes) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
932 |
FileMapInfo::fail_continue("The shared archive file's ObjectAlignmentInBytes of %d" |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32589
diff
changeset
|
933 |
" does not equal the current ObjectAlignmentInBytes of " INTX_FORMAT ".", |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
934 |
_obj_alignment, ObjectAlignmentInBytes); |
1 | 935 |
return false; |
936 |
} |
|
33628 | 937 |
if (_compact_strings != CompactStrings) { |
938 |
FileMapInfo::fail_continue("The shared archive file's CompactStrings setting (%s)" |
|
939 |
" does not equal the current CompactStrings setting (%s).", |
|
940 |
_compact_strings ? "enabled" : "disabled", |
|
941 |
CompactStrings ? "enabled" : "disabled"); |
|
942 |
return false; |
|
943 |
} |
|
1 | 944 |
|
945 |
return true; |
|
946 |
} |
|
947 |
||
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
948 |
bool FileMapInfo::validate_header() { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
949 |
bool status = _header->validate(); |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
950 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
951 |
if (status) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
952 |
if (!ClassLoader::check_shared_paths_misc_info(_paths_misc_info, _header->_paths_misc_info_size)) { |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
953 |
if (!PrintSharedArchiveAndExit) { |
38151
fffedc5e5cf8
8154110: Update class* and safepoint* logging subsystems
mockner
parents:
38108
diff
changeset
|
954 |
fail_continue("shared class paths mismatch (hint: enable -Xlog:class+path=info to diagnose the failure)"); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
955 |
status = false; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
956 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
957 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
958 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
959 |
|
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
960 |
if (_paths_misc_info != NULL) { |
27880
afb974a04396
8060074: os::free() takes MemoryTrackingLevel but doesn't need it
coleenp
parents:
27025
diff
changeset
|
961 |
FREE_C_HEAP_ARRAY(char, _paths_misc_info); |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
962 |
_paths_misc_info = NULL; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
963 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
964 |
return status; |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
965 |
} |
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
966 |
|
1 | 967 |
// The following method is provided to see whether a given pointer |
968 |
// falls in the mapped shared space. |
|
969 |
// Param: |
|
970 |
// p, The given pointer |
|
971 |
// Return: |
|
972 |
// True if the p is within the mapped shared space, otherwise, false. |
|
973 |
bool FileMapInfo::is_in_shared_space(const void* p) { |
|
13728
882756847a04
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
7405
diff
changeset
|
974 |
for (int i = 0; i < MetaspaceShared::n_regions; i++) { |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
975 |
char *base; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
976 |
if (MetaspaceShared::is_string_region(i) && _header->_space[i]._used == 0) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
977 |
continue; |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
978 |
} |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
979 |
base = _header->region_addr(i); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
980 |
if (p >= base && p < base + _header->_space[i]._used) { |
1 | 981 |
return true; |
982 |
} |
|
983 |
} |
|
984 |
||
985 |
return false; |
|
986 |
} |
|
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
987 |
|
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
988 |
// Check if a given address is within one of the shared regions ( ro, rw, mc or md) |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
989 |
bool FileMapInfo::is_in_shared_region(const void* p, int idx) { |
46746
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
990 |
assert(idx == MetaspaceShared::ro || |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
991 |
idx == MetaspaceShared::rw || |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
992 |
idx == MetaspaceShared::mc || |
ea379ebb9447
8072061: Automatically determine optimal sizes for the CDS regions
iklam
parents:
46742
diff
changeset
|
993 |
idx == MetaspaceShared::md, "invalid region index"); |
37439
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
994 |
char* base = _header->region_addr(idx); |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
995 |
if (p >= base && p < base + _header->_space[idx]._used) { |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
996 |
return true; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
997 |
} |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
998 |
return false; |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
999 |
} |
e8970711113b
8145221: Use trampolines for i2i and i2c entries in Methods that are stored in CDS archive
ccheung
parents:
37179
diff
changeset
|
1000 |
|
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
1001 |
void FileMapInfo::print_shared_spaces() { |
35061 | 1002 |
tty->print_cr("Shared Spaces:"); |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
1003 |
for (int i = 0; i < MetaspaceShared::n_regions; i++) { |
26135
82b516c550f7
8046070: Class Data Sharing clean up and refactoring
iklam
parents:
25715
diff
changeset
|
1004 |
struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[i]; |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
1005 |
char *base = _header->region_addr(i); |
35061 | 1006 |
tty->print(" %s " INTPTR_FORMAT "-" INTPTR_FORMAT, |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
1007 |
shared_region_name[i], |
33148
68fa8b6c4340
8042893: compiler: PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC needs to be removed from source files
david
parents:
32589
diff
changeset
|
1008 |
p2i(base), p2i(base + si->_used)); |
18483
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
1009 |
} |
c021907fa0a7
8016075: Win32 crash with CDS enabled and small heap size
iklam
parents:
17109
diff
changeset
|
1010 |
} |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1011 |
|
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1012 |
// Unmap mapped regions of shared space. |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1013 |
void FileMapInfo::stop_sharing_and_unmap(const char* msg) { |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1014 |
FileMapInfo *map_info = FileMapInfo::current_info(); |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1015 |
if (map_info) { |
26296 | 1016 |
map_info->fail_continue("%s", msg); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
1017 |
for (int i = 0; i < MetaspaceShared::num_non_strings; i++) { |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
1018 |
char *addr = map_info->_header->region_addr(i); |
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
1019 |
if (addr != NULL && !MetaspaceShared::is_string_region(i)) { |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1020 |
map_info->unmap_region(i); |
31345
1bba15125d8d
8015086: add interned strings to the shared archive.
jiangli
parents:
31332
diff
changeset
|
1021 |
map_info->_header->_space[i]._addr._base = NULL; |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1022 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1023 |
} |
32589
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
1024 |
// Dealloc the string regions only without unmapping. The string regions are part |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
1025 |
// of the java heap. Unmapping of the heap regions are managed by GC. |
f86fb16fcab0
8131734: assert(!is_null(v)) failed: narrow klass value can never be zero with -Xshared:auto
jiangli
parents:
31375
diff
changeset
|
1026 |
map_info->dealloc_string_regions(); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1027 |
} else if (DumpSharedSpaces) { |
26296 | 1028 |
fail_stop("%s", msg); |
19319
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1029 |
} |
0ad35be0733a
8003424: Enable Class Data Sharing for CompressedOops
hseigel
parents:
18483
diff
changeset
|
1030 |
} |