35 // read-write space from CompactingPermGenGen |
35 // read-write space from CompactingPermGenGen |
36 // read-only space from CompactingPermGenGen |
36 // read-only space from CompactingPermGenGen |
37 // misc data (block offset table, string table, symbols, dictionary, etc.) |
37 // misc data (block offset table, string table, symbols, dictionary, etc.) |
38 // tag(666) |
38 // tag(666) |
39 |
39 |
40 static const int JVM_SHARED_JARS_MAX = 128; |
|
41 static const int JVM_SPACENAME_MAX = 128; |
|
42 static const int JVM_IDENT_MAX = 256; |
40 static const int JVM_IDENT_MAX = 256; |
43 static const int JVM_ARCH_MAX = 12; |
|
44 |
|
45 |
41 |
46 class Metaspace; |
42 class Metaspace; |
|
43 |
|
44 class SharedClassPathEntry VALUE_OBJ_CLASS_SPEC { |
|
45 public: |
|
46 const char *_name; |
|
47 time_t _timestamp; // jar timestamp, 0 if is directory |
|
48 long _filesize; // jar file size, -1 if is directory |
|
49 bool is_dir() { |
|
50 return _filesize == -1; |
|
51 } |
|
52 }; |
47 |
53 |
48 class FileMapInfo : public CHeapObj<mtInternal> { |
54 class FileMapInfo : public CHeapObj<mtInternal> { |
49 private: |
55 private: |
|
56 friend class ManifestStream; |
50 enum { |
57 enum { |
51 _invalid_version = -1, |
58 _invalid_version = -1, |
52 _current_version = 1 |
59 _current_version = 2 |
53 }; |
60 }; |
54 |
61 |
55 bool _file_open; |
62 bool _file_open; |
56 int _fd; |
63 int _fd; |
57 long _file_offset; |
64 long _file_offset; |
58 |
65 |
|
66 private: |
|
67 static SharedClassPathEntry* _classpath_entry_table; |
|
68 static int _classpath_entry_table_size; |
|
69 static size_t _classpath_entry_size; |
|
70 static bool _validating_classpath_entry_table; |
|
71 |
59 // FileMapHeader describes the shared space data in the file to be |
72 // FileMapHeader describes the shared space data in the file to be |
60 // mapped. This structure gets written to a file. It is not a class, so |
73 // mapped. This structure gets written to a file. It is not a class, so |
61 // that the compilers don't add any compiler-private data to it. |
74 // that the compilers don't add any compiler-private data to it. |
62 |
75 |
63 struct FileMapHeader { |
76 public: |
|
77 struct FileMapHeaderBase : public CHeapObj<mtClass> { |
|
78 virtual bool validate() = 0; |
|
79 virtual void populate(FileMapInfo* info, size_t alignment) = 0; |
|
80 }; |
|
81 struct FileMapHeader : FileMapHeaderBase { |
|
82 // Use data() and data_size() to memcopy to/from the FileMapHeader. We need to |
|
83 // avoid read/writing the C++ vtable pointer. |
|
84 static size_t data_size(); |
|
85 char* data() { |
|
86 return ((char*)this) + sizeof(FileMapHeaderBase); |
|
87 } |
|
88 |
64 int _magic; // identify file type. |
89 int _magic; // identify file type. |
65 int _version; // (from enum, above.) |
90 int _version; // (from enum, above.) |
66 size_t _alignment; // how shared archive should be aligned |
91 size_t _alignment; // how shared archive should be aligned |
67 int _obj_alignment; // value of ObjectAlignmentInBytes |
92 int _obj_alignment; // value of ObjectAlignmentInBytes |
68 |
93 |
76 } _space[MetaspaceShared::n_regions]; |
101 } _space[MetaspaceShared::n_regions]; |
77 |
102 |
78 // The following fields are all sanity checks for whether this archive |
103 // The following fields are all sanity checks for whether this archive |
79 // will function correctly with this JVM and the bootclasspath it's |
104 // will function correctly with this JVM and the bootclasspath it's |
80 // invoked with. |
105 // invoked with. |
81 char _arch[JVM_ARCH_MAX]; // architecture |
|
82 char _jvm_ident[JVM_IDENT_MAX]; // identifier for jvm |
106 char _jvm_ident[JVM_IDENT_MAX]; // identifier for jvm |
83 int _num_jars; // Number of jars in bootclasspath |
107 |
84 |
108 // The _paths_misc_info is a variable-size structure that records "miscellaneous" |
85 // Per jar file data: timestamp, size. |
109 // information during dumping. It is generated and validated by the |
86 |
110 // SharedPathsMiscInfo class. See SharedPathsMiscInfo.hpp and sharedClassUtil.hpp for |
87 struct { |
111 // detailed description. |
88 time_t _timestamp; // jar timestamp. |
112 // |
89 long _filesize; // jar file size. |
113 // The _paths_misc_info data is stored as a byte array in the archive file header, |
90 } _jar[JVM_SHARED_JARS_MAX]; |
114 // immediately after the _header field. This information is used only when |
91 } _header; |
115 // checking the validity of the archive and is deallocated after the archive is loaded. |
|
116 // |
|
117 // Note that the _paths_misc_info does NOT include information for JAR files |
|
118 // that existed during dump time. Their information is stored in _classpath_entry_table. |
|
119 int _paths_misc_info_size; |
|
120 |
|
121 // The following is a table of all the class path entries that were used |
|
122 // during dumping. At run time, we require these files to exist and have the same |
|
123 // size/modification time, or else the archive will refuse to load. |
|
124 // |
|
125 // All of these entries must be JAR files. The dumping process would fail if a non-empty |
|
126 // directory was specified in the classpaths. If an empty directory was specified |
|
127 // it is checked by the _paths_misc_info as described above. |
|
128 // |
|
129 // FIXME -- if JAR files in the tail of the list were specified but not used during dumping, |
|
130 // they should be removed from this table, to save space and to avoid spurious |
|
131 // loading failures during runtime. |
|
132 int _classpath_entry_table_size; |
|
133 size_t _classpath_entry_size; |
|
134 SharedClassPathEntry* _classpath_entry_table; |
|
135 |
|
136 virtual bool validate(); |
|
137 virtual void populate(FileMapInfo* info, size_t alignment); |
|
138 }; |
|
139 |
|
140 FileMapHeader * _header; |
|
141 |
92 const char* _full_path; |
142 const char* _full_path; |
|
143 char* _paths_misc_info; |
93 |
144 |
94 static FileMapInfo* _current_info; |
145 static FileMapInfo* _current_info; |
95 |
146 |
96 bool init_from_file(int fd); |
147 bool init_from_file(int fd); |
97 void align_file_position(); |
148 void align_file_position(); |
|
149 bool validate_header_impl(); |
98 |
150 |
99 public: |
151 public: |
100 FileMapInfo() { |
152 FileMapInfo(); |
101 _file_offset = 0; |
153 ~FileMapInfo(); |
102 _file_open = false; |
|
103 _header._version = _invalid_version; |
|
104 } |
|
105 |
154 |
106 static int current_version() { return _current_version; } |
155 static int current_version() { return _current_version; } |
107 void populate_header(size_t alignment); |
156 void populate_header(size_t alignment); |
108 bool validate(); |
157 bool validate_header(); |
109 void invalidate(); |
158 void invalidate(); |
110 int version() { return _header._version; } |
159 int version() { return _header->_version; } |
111 size_t alignment() { return _header._alignment; } |
160 size_t alignment() { return _header->_alignment; } |
112 size_t space_capacity(int i) { return _header._space[i]._capacity; } |
161 size_t space_capacity(int i) { return _header->_space[i]._capacity; } |
113 char* region_base(int i) { return _header._space[i]._base; } |
162 char* region_base(int i) { return _header->_space[i]._base; } |
114 struct FileMapHeader* header() { return &_header; } |
163 struct FileMapHeader* header() { return _header; } |
115 |
|
116 static void set_current_info(FileMapInfo* info) { |
|
117 CDS_ONLY(_current_info = info;) |
|
118 } |
|
119 |
164 |
120 static FileMapInfo* current_info() { |
165 static FileMapInfo* current_info() { |
121 CDS_ONLY(return _current_info;) |
166 CDS_ONLY(return _current_info;) |
122 NOT_CDS(return NULL;) |
167 NOT_CDS(return NULL;) |
123 } |
168 } |
144 // Remap the shared readonly space to shared readwrite, private. |
189 // Remap the shared readonly space to shared readwrite, private. |
145 bool remap_shared_readonly_as_readwrite(); |
190 bool remap_shared_readonly_as_readwrite(); |
146 |
191 |
147 // Errors. |
192 // Errors. |
148 static void fail_stop(const char *msg, ...); |
193 static void fail_stop(const char *msg, ...); |
149 void fail_continue(const char *msg, ...); |
194 static void fail_continue(const char *msg, ...); |
150 |
195 |
151 // Return true if given address is in the mapped shared space. |
196 // Return true if given address is in the mapped shared space. |
152 bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false); |
197 bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false); |
153 void print_shared_spaces() NOT_CDS_RETURN; |
198 void print_shared_spaces() NOT_CDS_RETURN; |
154 |
199 |
158 os::vm_allocation_granularity()); |
203 os::vm_allocation_granularity()); |
159 } |
204 } |
160 |
205 |
161 // Stop CDS sharing and unmap CDS regions. |
206 // Stop CDS sharing and unmap CDS regions. |
162 static void stop_sharing_and_unmap(const char* msg); |
207 static void stop_sharing_and_unmap(const char* msg); |
|
208 |
|
209 static void allocate_classpath_entry_table(); |
|
210 bool validate_classpath_entry_table(); |
|
211 |
|
212 static SharedClassPathEntry* shared_classpath(int index) { |
|
213 char* p = (char*)_classpath_entry_table; |
|
214 p += _classpath_entry_size * index; |
|
215 return (SharedClassPathEntry*)p; |
|
216 } |
|
217 static const char* shared_classpath_name(int index) { |
|
218 return shared_classpath(index)->_name; |
|
219 } |
|
220 |
|
221 static int get_number_of_share_classpaths() { |
|
222 return _classpath_entry_table_size; |
|
223 } |
163 }; |
224 }; |
164 |
225 |
165 #endif // SHARE_VM_MEMORY_FILEMAP_HPP |
226 #endif // SHARE_VM_MEMORY_FILEMAP_HPP |