--- old/src/hotspot/share/memory/filemap.cpp 2019-10-10 17:16:34.714121070 -0700 +++ new/src/hotspot/share/memory/filemap.cpp 2019-10-10 17:16:34.458111883 -0700 @@ -34,6 +34,7 @@ #include "logging/log.hpp" #include "logging/logStream.hpp" #include "logging/logMessage.hpp" +#include "memory/archiveUtils.hpp" #include "memory/dynamicArchive.hpp" #include "memory/filemap.hpp" #include "memory/heapShared.inline.hpp" @@ -55,6 +56,7 @@ #include "runtime/vm_version.hpp" #include "services/memTracker.hpp" #include "utilities/align.hpp" +#include "utilities/bitMap.inline.hpp" #include "utilities/classpathStream.hpp" #include "utilities/defaultStream.hpp" #if INCLUDE_G1GC @@ -69,9 +71,6 @@ #define O_BINARY 0 // otherwise do nothing. #endif -extern address JVM_FunctionAtStart(); -extern address JVM_FunctionAtEnd(); - // Complain and stop. All error conditions occurring during the writing of // an archive file should stop the process. Unrecoverable errors during // the reading of the archive file should stop the process. @@ -104,12 +103,6 @@ void FileMapInfo::fail_continue(const char *msg, ...) { va_list ap; va_start(ap, msg); - if (_dynamic_archive_info == NULL) { - MetaspaceShared::set_archive_loading_failed(); - } else { - // _dynamic_archive_info has been setup after mapping the base archive - DynamicArchive::disable(); - } if (PrintSharedArchiveAndExit && _validating_shared_path_table) { // If we are doing PrintSharedArchiveAndExit and some of the classpath entries // do not validate, we can still continue "limping" to validate the remaining @@ -128,15 +121,6 @@ ls.vprint_cr(msg, ap); } } - if (_dynamic_archive_info == NULL) { - UseSharedSpaces = false; - assert(current_info() != NULL, "singleton must be registered"); - current_info()->close(); - } else { - // We are failing when loading the top archive, but the base archive should - // continue to work. - log_warning(cds, dynamic)("Unable to use shared archive. The top archive failed to load: %s", _dynamic_archive_info->_full_path); - } } va_end(ap); } @@ -227,9 +211,7 @@ _narrow_oop_base = CompressedOops::base(); _narrow_oop_shift = CompressedOops::shift(); _max_heap_size = MaxHeapSize; - _narrow_klass_base = CompressedKlassPointers::base(); _narrow_klass_shift = CompressedKlassPointers::shift(); - _shared_path_table = mapinfo->_shared_path_table; if (HeapShared::is_heap_object_archiving_allowed()) { _heap_end = CompressedOops::end(); } @@ -249,11 +231,16 @@ _verify_local = BytecodeVerificationLocal; _verify_remote = BytecodeVerificationRemote; _has_platform_or_app_classes = ClassLoaderExt::has_platform_or_app_classes(); - _shared_base_address = SharedBaseAddress; + _requested_base_address = (char*)SharedBaseAddress; + _mapped_base_address = (char*)SharedBaseAddress; _allow_archiving_with_java_agent = AllowArchivingWithJavaAgent; // the following 2 fields will be set in write_header for dynamic archive header _base_archive_name_size = 0; _base_archive_is_default = false; + + if (!DynamicDumpSharedSpaces) { + set_shared_path_table(mapinfo->_shared_path_table); + } } void SharedClassPathEntry::init_as_non_existent(const char* path, TRAPS) { @@ -617,7 +604,6 @@ bool FileMapInfo::fail(const char* msg, const char* name) { ClassLoader::trace_class_path(msg, name); - MetaspaceShared::set_archive_loading_failed(); return false; } @@ -952,8 +938,8 @@ // Read the FileMapInfo information from the file. -bool FileMapInfo::init_from_file(int fd, bool is_static) { - size_t sz = is_static ? sizeof(FileMapHeader) : sizeof(DynamicArchiveHeader); +bool FileMapInfo::init_from_file(int fd) { + size_t sz = is_static() ? sizeof(FileMapHeader) : sizeof(DynamicArchiveHeader); size_t n = os::read(fd, header(), (unsigned int)sz); if (n != sz) { fail_continue("Unable to read the file header."); @@ -965,7 +951,7 @@ return false; } - unsigned int expected_magic = is_static ? CDS_ARCHIVE_MAGIC : CDS_DYNAMIC_ARCHIVE_MAGIC; + unsigned int expected_magic = is_static() ? CDS_ARCHIVE_MAGIC : CDS_DYNAMIC_ARCHIVE_MAGIC; if (header()->magic() != expected_magic) { log_info(cds)("_magic expected: 0x%08x", expected_magic); log_info(cds)(" actual: 0x%08x", header()->magic()); @@ -1016,7 +1002,7 @@ _file_offset = n + header()->base_archive_name_size(); // accounts for the size of _base_archive_name - if (is_static) { + if (is_static()) { // just checking the last region is sufficient since the archive is written // in sequential order size_t len = lseek(fd, 0, SEEK_END); @@ -1026,8 +1012,6 @@ fail_continue("The shared archive file has been truncated."); return false; } - - SharedBaseAddress = header()->shared_base_address(); } return true; @@ -1040,23 +1024,27 @@ } // Read the FileMapInfo information from the file. -bool FileMapInfo::open_for_read(const char* path) { +bool FileMapInfo::open_for_read() { if (_file_open) { return true; } - if (path == NULL) { + if (is_static()) { _full_path = Arguments::GetSharedArchivePath(); } else { - _full_path = path; + _full_path = Arguments::GetSharedDynamicArchivePath(); } int fd = os::open(_full_path, O_RDONLY | O_BINARY, 0); if (fd < 0) { - if (errno == ENOENT) { - // Not locating the shared archive is ok. - fail_continue("Specified shared archive not found (%s).", _full_path); + if (is_static()) { + if (errno == ENOENT) { + // Not locating the shared archive is ok. + fail_continue("Specified shared archive not found (%s).", _full_path); + } else { + fail_continue("Failed to open shared archive file (%s).", + os::strerror(errno)); + } } else { - fail_continue("Failed to open shared archive file (%s).", - os::strerror(errno)); + log_warning(cds, dynamic)("specified dynamic archive doesn't exist: %s", _full_path); } return false; } @@ -1127,25 +1115,34 @@ } } +size_t FileMapRegion::used_aligned() const { + return align_up(used(), os::vm_allocation_granularity()); +} + void FileMapRegion::init(bool is_heap_region, char* base, size_t size, bool read_only, bool allow_exec, int crc) { _is_heap_region = is_heap_region; + _mapping_offset = 0; if (is_heap_region) { assert(!DynamicDumpSharedSpaces, "must be"); assert((base - (char*)CompressedKlassPointers::base()) % HeapWordSize == 0, "Sanity"); if (base != NULL) { - _addr._offset = (intx)CompressedOops::encode_not_null((oop)base); - } else { - _addr._offset = 0; + _mapping_offset = (size_t)CompressedOops::encode_not_null((oop)base); + assert(_mapping_offset >> 32 == 0, "must be 32-bit only"); } } else { - _addr._base = base; + if (base != NULL) { + assert(base >= (char*)SharedBaseAddress, "must be"); + _mapping_offset = base - (char*)SharedBaseAddress; + } } _used = size; _read_only = read_only; _allow_exec = allow_exec; _crc = crc; + _mapped_from_file = false; + _mapped_base = NULL; } void FileMapInfo::write_region(int region, char* base, size_t size, @@ -1154,15 +1151,19 @@ FileMapRegion* si = space_at(region); char* target_base = base; - if (DynamicDumpSharedSpaces) { + + if (region == MetaspaceShared::bm) { + target_base = NULL; + } else if (DynamicDumpSharedSpaces) { assert(!HeapShared::is_heap_region(region), "dynamic archive doesn't support heap regions"); target_base = DynamicArchive::buffer_to_target(base); } si->set_file_offset(_file_offset); - log_info(cds)("Shared file region %d: " SIZE_FORMAT_HEX_W(08) + char* requested_base = (target_base == NULL) ? NULL : target_base + MetaspaceShared::final_delta(); + log_info(cds)("Shared file region %d: " SIZE_FORMAT_HEX_W(08) " bytes, addr " INTPTR_FORMAT " file offset " SIZE_FORMAT_HEX_W(08), - region, size, p2i(target_base), _file_offset); + region, size, p2i(requested_base), _file_offset); int crc = ClassLoader::crc32(0, base, (jint)size); si->init(HeapShared::is_heap_region(region), target_base, size, read_only, allow_exec, crc); @@ -1172,6 +1173,20 @@ } } + +void FileMapInfo::write_bitmap_region(const CHeapBitMap* ptrmap) { + ResourceMark rm; + size_t size_in_bits = ptrmap->size(); + size_t size_in_bytes = ptrmap->size_in_bytes(); + uintptr_t* buffer = (uintptr_t*)NEW_RESOURCE_ARRAY(char, size_in_bytes); + ptrmap->write_to(buffer, size_in_bytes); + header()->set_ptrmap_size_in_bits(size_in_bits); + + log_info(cds)("ptrmap = " INTPTR_FORMAT " (" SIZE_FORMAT " bytes)", + p2i(buffer), size_in_bytes); + write_region(MetaspaceShared::bm, (char*)buffer, size_in_bytes, /*read_only=*/true, /*allow_exec=*/false); +} + // Write out the given archive heap memory regions. GC code combines multiple // consecutive archive GC regions into one MemRegion whenever possible and // produces the 'heap_mem' array. @@ -1229,11 +1244,13 @@ total_size += size; } - log_info(cds)("Archive heap region %d " INTPTR_FORMAT " - " INTPTR_FORMAT " = " SIZE_FORMAT_W(8) " bytes", + log_info(cds)("Archive heap region %d: " INTPTR_FORMAT " - " INTPTR_FORMAT " = " SIZE_FORMAT_W(8) " bytes", i, p2i(start), p2i(start + size), size); write_region(i, start, size, false, false); if (size > 0) { - space_at(i)->init_oopmap(oopmaps->at(arr_idx)._oopmap, + address oopmap = oopmaps->at(arr_idx)._oopmap; + assert(oopmap >= (address)SharedBaseAddress, "must be"); + space_at(i)->init_oopmap(oopmap - (address)SharedBaseAddress, oopmaps->at(arr_idx)._oopmap_size_in_bits); } } @@ -1285,6 +1302,9 @@ align_file_position(); } +void FileMapInfo::set_final_requested_base(char* b) { + header()->set_final_requested_base(b); +} // Close the shared archive file. This does NOT unmap mapped regions. @@ -1331,94 +1351,189 @@ return true; } -// Map the whole region at once, assumed to be allocated contiguously. -ReservedSpace FileMapInfo::reserve_shared_memory() { - char* requested_addr = region_addr(0); - size_t size = FileMapInfo::core_spaces_size(); - - // Reserve the space first, then map otherwise map will go right over some - // other reserved memory (like the code cache). - ReservedSpace rs(size, os::vm_allocation_granularity(), false, requested_addr); - if (!rs.is_reserved()) { - fail_continue("Unable to reserve shared space at required address " - INTPTR_FORMAT, p2i(requested_addr)); - return rs; +// Memory map a region in the address space. +static const char* shared_region_name[] = { "MiscData", "ReadWrite", "ReadOnly", "MiscCode", "Bitmap", + "String1", "String2", "OpenArchive1", "OpenArchive2" }; + +MapArchiveResult FileMapInfo::map_regions(int regions[], int num_regions, char* mapped_base_address, ReservedSpace rs) { + FileMapRegion* last_region = NULL; + intx addr_delta = mapped_base_address - header()->requested_base_address(); + + DEBUG_ONLY(header()->set_mapped_base_address((char*)(uintptr_t)0xdeadbeef);) + + for (int r = 0; r < num_regions; r++) { + int idx = regions[r]; + MapArchiveResult result = map_region(idx, addr_delta, mapped_base_address, rs); + if (result != MAP_ARCHIVE_SUCCESS) { + return result; + } + FileMapRegion* si = space_at(idx); + if (last_region != NULL) { + // Ensure that the OS won't be able to allocate new memory spaces between any mapped + // regions, or else it would mess up the simple comparision in MetaspaceObj::is_shared(). + assert(si->mapped_base() == last_region->mapped_end(), "must have no gaps"); + } + log_info(cds)("Mapped %s region #%d at base " INTPTR_FORMAT " top " INTPTR_FORMAT " (%s)", is_static() ? "static " : "dynamic", + idx, p2i(si->mapped_base()), p2i(si->mapped_end()), + shared_region_name[idx]); + last_region = si; } - // the reserved virtual memory is for mapping class data sharing archive - MemTracker::record_virtual_memory_type((address)rs.base(), mtClassShared); - return rs; -} + DEBUG_ONLY(if (addr_delta == 0 && SharedBaseAddress == 0) { + // This is for simulating mmap failures at the requested location, so we can thoroughly + // test the code for failure handling (releasing all allocated resource) and retry mapping + // at an alternative address picked by the OS. + log_info(cds)("SharedBaseAddress == 0: always map archive(s) at an alternative address"); + return MAP_ARCHIVE_MMAP_FAILURE; + }); -// Memory map a region in the address space. -static const char* shared_region_name[] = { "MiscData", "ReadWrite", "ReadOnly", "MiscCode", - "String1", "String2", "OpenArchive1", "OpenArchive2" }; + header()->set_mapped_base_address(header()->requested_base_address() + addr_delta); + if (addr_delta != 0 && !relocate_pointers(addr_delta)) { + return MAP_ARCHIVE_OTHER_FAILURE; + } -char* FileMapInfo::map_regions(int regions[], char* saved_base[], size_t len) { - char* prev_top = NULL; - char* curr_base; - char* curr_top; - int i = 0; - for (i = 0; i < (int)len; i++) { - curr_base = map_region(regions[i], &curr_top); - if (curr_base == NULL) { - return NULL; - } - if (i > 0) { - // We require that mc->rw->ro->md to be laid out consecutively, with no - // gaps between them. That way, we can ensure that the OS won't be able to - // allocate any new memory spaces inside _shared_metaspace_{base,top}, which - // would mess up the simple comparision in MetaspaceShared::is_in_shared_metaspace(). - assert(curr_base == prev_top, "must be"); - } - log_info(cds)("Mapped region #%d at base %p top %p", regions[i], curr_base, curr_top); - saved_base[i] = curr_base; - prev_top = curr_top; + return MAP_ARCHIVE_SUCCESS; +} + +bool FileMapInfo::read_region(int i, char* base, size_t size) { + assert(MetaspaceShared::use_windows_memory_mapping(), "used by windows only"); + FileMapRegion* si = space_at(i); + log_info(cds)("Commit %s region #%d at base " INTPTR_FORMAT " top " INTPTR_FORMAT " (%s)%s", + is_static() ? "static " : "dynamic", i, p2i(base), p2i(base + size), + shared_region_name[i], si->allow_exec() ? " exec" : ""); + if (!os::commit_memory(base, size, si->allow_exec())) { + log_error(cds)("Failed to commit %s region #%d (%s)", is_static() ? "static " : "dynamic", + i, shared_region_name[i]); + return false; + } + if (lseek(_fd, (long)si->file_offset(), SEEK_SET) != (int)si->file_offset() || + read_bytes(base, size) != size) { + return false; } - return curr_top; + return true; } -char* FileMapInfo::map_region(int i, char** top_ret) { +MapArchiveResult FileMapInfo::map_region(int i, intx addr_delta, char* mapped_base_address, ReservedSpace rs) { assert(!HeapShared::is_heap_region(i), "sanity"); FileMapRegion* si = space_at(i); - size_t used = si->used(); - size_t alignment = os::vm_allocation_granularity(); - size_t size = align_up(used, alignment); - char *requested_addr = region_addr(i); - -#ifdef _WINDOWS - // Windows cannot remap read-only shared memory to read-write when required for - // RedefineClasses, which is also used by JFR. Always map windows regions as RW. - si->set_read_only(false); -#else - // If a tool agent is in use (debugging enabled), or JFR, we must map the address space RW - if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space() || - Arguments::has_jfr_option()) { + size_t size = si->used_aligned(); + char *requested_addr = mapped_base_address + si->mapping_offset(); + assert(si->mapped_base() == NULL, "must be not mapped yet"); + assert(requested_addr != NULL, "must be specified"); + + si->set_mapped_from_file(false); + + if (MetaspaceShared::use_windows_memory_mapping()) { + // Windows cannot remap read-only shared memory to read-write when required for + // RedefineClasses, which is also used by JFR. Always map windows regions as RW. + si->set_read_only(false); + } else if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space() || + Arguments::has_jfr_option()) { + // If a tool agent is in use (debugging enabled), or JFR, we must map the address space RW si->set_read_only(false); + } else if (addr_delta != 0) { + si->set_read_only(false); // Need to patch the pointers } -#endif // _WINDOWS - // map the contents of the CDS archive in this memory - char *base = os::map_memory(_fd, _full_path, si->file_offset(), - requested_addr, size, si->read_only(), - si->allow_exec()); - if (base == NULL || base != requested_addr) { - fail_continue("Unable to map %s shared space at required address.", shared_region_name[i]); - _memory_mapping_failed = true; - return NULL; + if (rs.is_reserved()) { + assert(rs.contains(requested_addr) && rs.contains(requested_addr + size - 1), "must be"); + MemTracker::record_virtual_memory_type((address)requested_addr, mtClassShared); + } + + if (MetaspaceShared::use_windows_memory_mapping() && addr_delta != 0) { + // This is the second time we try to map the archive(s). We have already created a ReservedSpace + // that covers all the FileMapRegions to ensure all regions can be mapped. However, Windows + // can't mmap into a ReservedSpace, so we just os::read() the data. We're going to patch all the + // regions anyway, so there's no benefit for mmap anyway. + if (!read_region(i, requested_addr, size)) { + return MAP_ARCHIVE_OTHER_FAILURE; // oom or I/O error. + } + } else { + char* base = os::map_memory(_fd, _full_path, si->file_offset(), + requested_addr, size, si->read_only(), + si->allow_exec()); + if (base != requested_addr) { + log_info(cds)("Unable to map %s shared space at required address.", shared_region_name[i]); + _memory_mapping_failed = true; + return MAP_ARCHIVE_MMAP_FAILURE; + } + si->set_mapped_from_file(true); + } + si->set_mapped_base(requested_addr); + + if (!rs.is_reserved()) { + // When mapping on Windows with (addr_delta == 0), we don't reserve the address space for the regions + // (Windows can't mmap into a ReservedSpace). In this case, NMT requires we call it after + // os::map_memory has succeeded. + MemTracker::record_virtual_memory_type((address)requested_addr, mtClassShared); } -#ifdef _WINDOWS - // This call is Windows-only because the memory_type gets recorded for the other platforms - // in method FileMapInfo::reserve_shared_memory(), which is not called on Windows. - MemTracker::record_virtual_memory_type((address)base, mtClassShared); -#endif if (VerifySharedSpaces && !verify_region_checksum(i)) { + return MAP_ARCHIVE_OTHER_FAILURE; + } + + return MAP_ARCHIVE_SUCCESS; +} + +char* FileMapInfo::map_relocation_bitmap(size_t& bitmap_size) { + FileMapRegion* si = space_at(MetaspaceShared::bm); + bitmap_size = si->used_aligned(); + bool read_only = true, allow_exec = false; + char* requested_addr = NULL; // allow OS to pick any location + char* bitmap_base = os::map_memory(_fd, _full_path, si->file_offset(), + requested_addr, bitmap_size, read_only, allow_exec); + + if (VerifySharedSpaces && bitmap_base != NULL && !region_crc_check(bitmap_base, bitmap_size, si->crc())) { + log_error(cds)("relocation bitmap CRC error"); + if (!os::unmap_memory(bitmap_base, bitmap_size)) { + fatal("os::unmap_memory of relocation bitmap failed"); + } return NULL; } + return bitmap_base; +} + +bool FileMapInfo::relocate_pointers(intx addr_delta) { + log_debug(cds, reloc)("runtime archive relocation start"); + size_t bitmap_size; + char* bitmap_base = map_relocation_bitmap(bitmap_size); + + if (bitmap_base != NULL) { + size_t ptrmap_size_in_bits = header()->ptrmap_size_in_bits(); + log_debug(cds, reloc)("mapped relocation bitmap @ " INTPTR_FORMAT " (" SIZE_FORMAT + " bytes = " SIZE_FORMAT " bits)", + p2i(bitmap_base), bitmap_size, ptrmap_size_in_bits); + + BitMapView ptrmap((BitMap::bm_word_t*)bitmap_base, ptrmap_size_in_bits); + + // Patch all pointers in the the mapped region that are marked by ptrmap. + address patch_base = (address)mapped_base(); + address patch_end = (address)mapped_end(); - *top_ret = base + size; - return base; + // debug only -- the current value of the pointers to be patched must be within this + // range (i.e., must be between the requesed base address, and the of the current archive). + // Note: top archive may point to objects in the base archive, but not the other way around. + address valid_old_base = (address)header()->requested_base_address(); + address valid_old_end = valid_old_base + mapping_end_offset(); + + // debug only -- after patching, the pointers must point inside this range + // (the requested location of the archive, as mapped at runtime). + address valid_new_base = (address)header()->mapped_base_address(); + address valid_new_end = (address)mapped_end(); + + SharedDataRelocator patcher((address*)patch_base, (address*)patch_end, valid_old_base, valid_old_end, + valid_new_base, valid_new_end, addr_delta); + ptrmap.iterate(&patcher); + + if (!os::unmap_memory(bitmap_base, bitmap_size)) { + fatal("os::unmap_memory of relocation bitmap failed"); + } + log_debug(cds, reloc)("runtime archive relocation done"); + return true; + } else { + log_error(cds)("failed to map relocation bitmap"); + return false; + } } size_t FileMapInfo::read_bytes(void* buffer, size_t count) { @@ -1434,10 +1549,13 @@ } address FileMapInfo::decode_start_address(FileMapRegion* spc, bool with_current_oop_encoding_mode) { + size_t offset = spc->mapping_offset(); + assert((offset >> 32) == 0, "must be 32-bit only"); + uint n = (uint)offset; if (with_current_oop_encoding_mode) { - return (address)CompressedOops::decode_not_null(spc->offset()); + return (address)CompressedOops::decode_not_null(n); } else { - return (address)HeapShared::decode_from_archive(spc->offset()); + return (address)HeapShared::decode_from_archive(n); } } @@ -1705,7 +1823,7 @@ int first_region_idx) { for (int i=0; ioopmap(), + HeapShared::patch_archived_heap_embedded_pointers(ranges[i], (address)(SharedBaseAddress + si->oopmap_offset()), si->oopmap_size_in_bits()); } } @@ -1759,11 +1877,10 @@ } } -void FileMapInfo::unmap_regions(int regions[], char* saved_base[], size_t len) { - for (int i = 0; i < (int)len; i++) { - if (saved_base[i] != NULL) { - unmap_region(regions[i]); - } +void FileMapInfo::unmap_regions(int regions[], int num_regions) { + for (int r = 0; r < num_regions; r++) { + int idx = regions[r]; + unmap_region(idx); } } @@ -1772,16 +1889,17 @@ void FileMapInfo::unmap_region(int i) { assert(!HeapShared::is_heap_region(i), "sanity"); FileMapRegion* si = space_at(i); + char* mapped_base = si->mapped_base(); size_t used = si->used(); size_t size = align_up(used, os::vm_allocation_granularity()); - if (used == 0) { - return; - } - - char* addr = region_addr(i); - if (!os::unmap_memory(addr, size)) { - fail_stop("Unable to unmap shared space."); + if (mapped_base != NULL && size > 0 && si->mapped_from_file()) { + log_info(cds)("Unmapping region #%d at base " INTPTR_FORMAT " (%s)", i, p2i(mapped_base), + shared_region_name[i]); + if (!os::unmap_memory(mapped_base, size)) { + fatal("os::unmap_memory failed"); + } + si->set_mapped_base(NULL); } } @@ -1813,7 +1931,7 @@ // [1] validate_header() - done here. // [2] validate_shared_path_table - this is done later, because the table is in the RW // region of the archive, which is not mapped yet. -bool FileMapInfo::initialize(bool is_static) { +bool FileMapInfo::initialize() { assert(UseSharedSpaces, "UseSharedSpaces expected."); if (JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()) { @@ -1828,11 +1946,10 @@ if (!open_for_read()) { return false; } - - init_from_file(_fd, is_static); - // UseSharedSpaces could be disabled if the checking of some of the header fields in - // init_from_file has failed. - if (!UseSharedSpaces || !validate_header(is_static)) { + if (!init_from_file(_fd)) { + return false; + } + if (!validate_header()) { return false; } return true; @@ -1845,10 +1962,18 @@ return si->used() > 0 ? (char*)start_address_as_decoded_with_current_oop_encoding_mode(si) : NULL; } else { - return si->base(); + return si->mapped_base(); } } +FileMapRegion* FileMapInfo::first_core_space() const { + return is_static() ? space_at(MetaspaceShared::mc) : space_at(MetaspaceShared::rw); +} + +FileMapRegion* FileMapInfo::last_core_space() const { + return is_static() ? space_at(MetaspaceShared::md) : space_at(MetaspaceShared::mc); +} + int FileMapHeader::compute_crc() { char* start = (char*)this; // start computing from the field after _crc @@ -1860,7 +1985,6 @@ // This function should only be called during run time with UseSharedSpaces enabled. bool FileMapHeader::validate() { - if (_obj_alignment != ObjectAlignmentInBytes) { FileMapInfo::fail_continue("The shared archive file's ObjectAlignmentInBytes of %d" " does not equal the current ObjectAlignmentInBytes of " INTX_FORMAT ".", @@ -1913,7 +2037,7 @@ return true; } -bool FileMapInfo::validate_header(bool is_static) { +bool FileMapInfo::validate_header() { return header()->validate(); } @@ -1932,18 +2056,14 @@ // Unmap mapped regions of shared space. void FileMapInfo::stop_sharing_and_unmap(const char* msg) { - MetaspaceShared::set_shared_metaspace_range(NULL, NULL); + MetaspaceShared::set_shared_metaspace_range(NULL, NULL, NULL); FileMapInfo *map_info = FileMapInfo::current_info(); if (map_info) { map_info->fail_continue("%s", msg); for (int i = 0; i < MetaspaceShared::num_non_heap_spaces; i++) { if (!HeapShared::is_heap_region(i)) { - char *addr = map_info->region_addr(i); - if (addr != NULL) { - map_info->unmap_region(i); - map_info->space_at(i)->mark_invalid(); - } + map_info->unmap_region(i); } } // Dealloc the archive heap regions only without unmapping. The regions are part