jdk-sandbox: comparison src/hotspot/share/memory/filemap.cpp

equal deleted inserted replaced

-:e0d59f0c2b7d
+:22ee476cc664
 #include "classfile/systemDictionaryShared.hpp"
 #include "classfile/altHashing.hpp"
 #include "logging/log.hpp"
 #include "logging/logStream.hpp"
 #include "logging/logMessage.hpp"
+#include "memory/archiveUtils.inline.hpp"
 #include "memory/dynamicArchive.hpp"
 #include "memory/filemap.hpp"
 #include "memory/heapShared.inline.hpp"
 #include "memory/iterator.inline.hpp"
 #include "memory/metadataFactory.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/os.inline.hpp"
 #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
 #include "gc/g1/g1CollectedHeap.hpp"
 #include "gc/g1/heapRegion.hpp"
 # include <errno.h>
 #ifndef O_BINARY       // if defined (Win32) use binary files.
 #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.
 // If we continue, then disable shared spaces and close the file.
 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
 // entries. No need to quit.
 tty->print("[");
 LogStream ls(Log(cds)::info());
 ls.print("UseSharedSpaces: ");
 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);
 }
 // Fill in the fileMapInfo structure with data about this VM instance.
 _compact_strings = CompactStrings;
 _narrow_oop_mode = CompressedOops::mode();
 _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();
 }
 // The following fields are for sanity checks for whether this archive
 _max_used_path_index = ClassLoaderExt::max_used_path_index();
 _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) {
 _type = non_existent_entry;
 set_name(path, THREAD);
 }
 }
 return path_array;
 }
-bool FileMapInfo::fail(const char* msg, const char* name) {
+bool FileMapInfo::classpath_failure(const char* msg, const char* name) {
 ClassLoader::trace_class_path(msg, name);
-MetaspaceShared::set_archive_loading_failed();
+if (PrintSharedArchiveAndExit) {
+MetaspaceShared::set_archive_loading_failed();
+}
 return false;
 }
 bool FileMapInfo::check_paths(int shared_path_start_idx, int num_paths, GrowableArray<const char*>* rp_array) {
 int i = 0;
 }
 }
 if (mismatch) {
 // The paths are different
-return fail("[BOOT classpath mismatch, actual =", runtime_boot_path);
+return classpath_failure("[BOOT classpath mismatch, actual =", runtime_boot_path);
 }
 return true;
 }
 bool FileMapInfo::validate_app_class_paths(int shared_app_paths_len) {
 const char *appcp = Arguments::get_appclasspath();
 assert(appcp != NULL, "NULL app classpath");
 int rp_len = num_paths(appcp);
 bool mismatch = false;
 if (rp_len < shared_app_paths_len) {
-return fail("Run time APP classpath is shorter than the one at dump time: ", appcp);
+return classpath_failure("Run time APP classpath is shorter than the one at dump time: ", appcp);
 }
 if (shared_app_paths_len != 0 && rp_len != 0) {
 // Prefix is OK: E.g., dump with -cp foo.jar, but run with -cp foo.jar:bar.jar.
 ResourceMark rm;
 GrowableArray<const char*>* rp_array = create_path_array(appcp);
 if (rp_array->length() == 0) {
 // None of the jar file specified in the runtime -cp exists.
-return fail("None of the jar file specified in the runtime -cp exists: -Djava.class.path=", appcp);
+return classpath_failure("None of the jar file specified in the runtime -cp exists: -Djava.class.path=", appcp);
 }
 // Handling of non-existent entries in the classpath: we eliminate all the non-existent
 // entries from both the dump time classpath (ClassLoader::update_class_path_entry_list)
 // and the runtime classpath (FileMapInfo::create_path_array), and check the remaining
 // run 2: -cp x.jar:NE4:b.jar      -> x.jar:b.jar -> mismatched
 int j = header()->app_class_paths_start_index();
 mismatch = check_paths(j, shared_app_paths_len, rp_array);
 if (mismatch) {
-return fail("[APP classpath mismatch, actual: -Djava.class.path=", appcp);
+return classpath_failure("[APP classpath mismatch, actual: -Djava.class.path=", appcp);
 }
 }
 return true;
 }
 _shared_path_table = _current_info->header()->shared_path_table();
 }
 // Read the FileMapInfo information from the file.
-bool FileMapInfo::init_from_file(int fd, bool is_static) {
+bool FileMapInfo::init_from_file(int fd) {
-size_t sz = is_static ? sizeof(FileMapHeader) : sizeof(DynamicArchiveHeader);
+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.");
 return false;
 }
 if (!Arguments::has_jimage()) {
 FileMapInfo::fail_continue("The shared archive file cannot be used with an exploded module build.");
 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());
 FileMapInfo::fail_continue("The shared archive file has a bad magic number.");
 return false;
 }
 }
 _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);
 FileMapRegion* si = space_at(MetaspaceShared::last_valid_region);
 // The last space might be empty
 if (si->file_offset() > len || len - si->file_offset() < si->used()) {
 fail_continue("The shared archive file has been truncated.");
 return false;
 }
-SharedBaseAddress = header()->shared_base_address();
 }
 return true;
 }
 fail_stop("Unable to seek to position " SIZE_FORMAT, pos);
 }
 }
 // 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) {
+if (is_static()) {
-// Not locating the shared archive is ok.
+if (errno == ENOENT) {
-fail_continue("Specified shared archive not found (%s).", _full_path);
+// 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).",
+log_warning(cds, dynamic)("specified dynamic archive doesn't exist: %s", _full_path);
-os::strerror(errno));
 }
 return false;
 }
 _fd = fd;
 if (base_archive_name != NULL) {
 write_bytes(base_archive_name, header()->base_archive_name_size());
 }
 }
-void FileMapRegion::init(bool is_heap_region, char* base, size_t size, bool read_only,
+size_t FileMapRegion::used_aligned() const {
+return align_up(used(), os::vm_allocation_granularity());
+}
+void FileMapRegion::init(int region_index, char* base, size_t size, bool read_only,
 bool allow_exec, int crc) {
-_is_heap_region = is_heap_region;
+_is_heap_region = HeapShared::is_heap_region(region_index);
+_is_bitmap_region = (region_index == MetaspaceShared::bm);
-if (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);
+_mapping_offset = (size_t)CompressedOops::encode_not_null((oop)base);
-} else {
+assert(_mapping_offset >> 32 == 0, "must be 32-bit only");
-_addr._offset = 0;
+}
-}
+} else {
-} else {
+if (base != NULL) {
-_addr._base = base;
+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,
 bool read_only, bool allow_exec) {
 Arguments::assert_is_dumping_archive();
 FileMapRegion* si = space_at(region);
-char* target_base = base;
+char* target_base;
-if (DynamicDumpSharedSpaces) {
-assert(!HeapShared::is_heap_region(region), "dynamic archive doesn't support heap regions");
+if (region == MetaspaceShared::bm) {
-target_base = DynamicArchive::buffer_to_target(base);
+target_base = NULL; // always NULL for bm region.
+} else {
+if (DynamicDumpSharedSpaces) {
+assert(!HeapShared::is_heap_region(region), "dynamic archive doesn't support heap regions");
+target_base = DynamicArchive::buffer_to_target(base);
+} else {
+target_base = 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);
+si->init(region, target_base, size, read_only, allow_exec, crc);
 if (base != NULL) {
 write_bytes_aligned(base, size);
 }
+}
+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.
 start = (char*)heap_mem->at(arr_idx).start();
 size = heap_mem->at(arr_idx).byte_size();
 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);
 }
 }
 return total_size;
 }
 align_file_position();
 write_bytes(buffer, nbytes);
 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.
 void FileMapInfo::close() {
 if (_file_open) {
 }
 si->set_read_only(false);
 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;
-}
-// the reserved virtual memory is for mapping class data sharing archive
-MemTracker::record_virtual_memory_type((address)rs.base(), mtClassShared);
-return rs;
-}
 // Memory map a region in the address space.
-static const char* shared_region_name[] = { "MiscData", "ReadWrite", "ReadOnly", "MiscCode",
+static const char* shared_region_name[] = { "MiscData", "ReadWrite", "ReadOnly", "MiscCode", "Bitmap",
 "String1", "String2", "OpenArchive1", "OpenArchive2" };
-char* FileMapInfo::map_regions(int regions[], char* saved_base[], size_t len) {
+MapArchiveResult FileMapInfo::map_regions(int regions[], int num_regions, char* mapped_base_address, ReservedSpace rs) {
-char* prev_top = NULL;
+DEBUG_ONLY(FileMapRegion* last_region = NULL);
-char* curr_base;
+intx addr_delta = mapped_base_address - header()->requested_base_address();
-char* curr_top;
-int i = 0;
+// Make sure we don't attempt to use header()->mapped_base_address() unless
-for (i = 0; i < (int)len; i++) {
+// it's been successfully mapped.
-curr_base = map_region(regions[i], &curr_top);
+DEBUG_ONLY(header()->set_mapped_base_address((char*)(uintptr_t)0xdeadbeef);)
-if (curr_base == NULL) {
-return NULL;
+for (int r = 0; r < num_regions; r++) {
-}
+int idx = regions[r];
-if (i > 0) {
+MapArchiveResult result = map_region(idx, addr_delta, mapped_base_address, rs);
-// We require that mc->rw->ro->md to be laid out consecutively, with no
+if (result != MAP_ARCHIVE_SUCCESS) {
-// gaps between them. That way, we can ensure that the OS won't be able to
+return result;
-// allocate any new memory spaces inside _shared_metaspace_{base,top}, which
+}
-// would mess up the simple comparision in MetaspaceShared::is_in_shared_metaspace().
+FileMapRegion* si = space_at(idx);
-assert(curr_base == prev_top, "must be");
+DEBUG_ONLY(if (last_region != NULL) {
-}
+// Ensure that the OS won't be able to allocate new memory spaces between any mapped
-log_info(cds)("Mapped region #%d at base %p top %p", regions[i], curr_base, curr_top);
+// regions, or else it would mess up the simple comparision in MetaspaceObj::is_shared().
-saved_base[i] = curr_base;
+assert(si->mapped_base() == last_region->mapped_end(), "must have no gaps");
-prev_top = curr_top;
+}
-}
+last_region = si;)
-return curr_top;
+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]);
-char* FileMapInfo::map_region(int i, char** top_ret) {
+}
+DEBUG_ONLY(if (addr_delta == 0 && ArchiveRelocationMode == 1) {
+// This is for simulating mmap failures at the requested address. We do it here (instead
+// of MetaspaceShared::map_archives) so we can thoroughly test the code for failure handling
+// (releasing all allocated resource, etc).
+log_info(cds)("ArchiveRelocationMode == 1: always map archive(s) at an alternative address");
+return MAP_ARCHIVE_MMAP_FAILURE;
+});
+header()->set_mapped_base_address(header()->requested_base_address() + addr_delta);
+if (addr_delta != 0 && !relocate_pointers(addr_delta)) {
+return MAP_ARCHIVE_OTHER_FAILURE;
+}
+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 true;
+}
+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 size = si->used_aligned();
-size_t alignment = os::vm_allocation_granularity();
+char *requested_addr = mapped_base_address + si->mapping_offset();
-size_t size = align_up(used, alignment);
+assert(si->mapped_base() == NULL, "must be not mapped yet");
-char *requested_addr = region_addr(i);
+assert(requested_addr != NULL, "must be specified");
-#ifdef _WINDOWS
+si->set_mapped_from_file(false);
-// 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.
+if (MetaspaceShared::use_windows_memory_mapping()) {
-si->set_read_only(false);
+// Windows cannot remap read-only shared memory to read-write when required for
-#else
+// RedefineClasses, which is also used by JFR.  Always map windows regions as RW.
-// 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()) {
 si->set_read_only(false);
-}
+} else if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space() ||
-#endif // _WINDOWS
+Arguments::has_jfr_option()) {
+// If a tool agent is in use (debugging enabled), or JFR, we must map the address space RW
-// map the contents of the CDS archive in this memory
+si->set_read_only(false);
-char *base = os::map_memory(_fd, _full_path, si->file_offset(),
+} else if (addr_delta != 0) {
-requested_addr, size, si->read_only(),
+si->set_read_only(false); // Need to patch the pointers
-si->allow_exec());
+}
-if (base == NULL || base != requested_addr) {
-fail_continue("Unable to map %s shared space at required address.", shared_region_name[i]);
+if (rs.is_reserved()) {
-_memory_mapping_failed = true;
+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.
+assert(MetaspaceShared::use_windows_memory_mapping(), "Windows memory mapping only");
+MemTracker::record_virtual_memory_type((address)requested_addr, mtClassShared);
+}
+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 (bitmap_base == NULL) {
+log_error(cds)("failed to map relocation bitmap");
 return NULL;
 }
-#ifdef _WINDOWS
-// This call is Windows-only because the memory_type gets recorded for the other platforms
+if (VerifySharedSpaces && !region_crc_check(bitmap_base, bitmap_size, si->crc())) {
-// in method FileMapInfo::reserve_shared_memory(), which is not called on Windows.
+log_error(cds)("relocation bitmap CRC error");
-MemTracker::record_virtual_memory_type((address)base, mtClassShared);
+if (!os::unmap_memory(bitmap_base, bitmap_size)) {
-#endif
+fatal("os::unmap_memory of relocation bitmap failed");
+}
-if (VerifySharedSpaces && !verify_region_checksum(i)) {
 return NULL;
 }
-*top_ret = base + size;
+return bitmap_base;
-return 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) {
+return false;
+} else {
+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();
+// 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();
+// 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<false> 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;
+}
 }
 size_t FileMapInfo::read_bytes(void* buffer, size_t count) {
 assert(_file_open, "Archive file is not open");
 size_t n = os::read(_fd, buffer, (unsigned int)count);
 _file_offset += count;
 return count;
 }
 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);
 }
 }
 static MemRegion *closed_archive_heap_ranges = NULL;
 static MemRegion *open_archive_heap_ranges = NULL;
 void FileMapInfo::patch_archived_heap_embedded_pointers(MemRegion* ranges, int num_ranges,
 int first_region_idx) {
 for (int i=0; i<num_ranges; i++) {
 FileMapRegion* si = space_at(i + first_region_idx);
-HeapShared::patch_archived_heap_embedded_pointers(ranges[i], (address)si->oopmap(),
+HeapShared::patch_archived_heap_embedded_pointers(ranges[i], (address)(SharedBaseAddress + si->oopmap_offset()),
 si->oopmap_size_in_bits());
 }
 }
 // This internally allocates objects using SystemDictionary::Object_klass(), so it
 } else {
 return region_crc_check(region_addr(i), sz, space_at(i)->crc());
 }
 }
-void FileMapInfo::unmap_regions(int regions[], char* saved_base[], size_t len) {
+void FileMapInfo::unmap_regions(int regions[], int num_regions) {
-for (int i = 0; i < (int)len; i++) {
+for (int r = 0; r < num_regions; r++) {
-if (saved_base[i] != NULL) {
+int idx = regions[r];
-unmap_region(regions[i]);
+unmap_region(idx);
-}
 }
 }
 // Unmap a memory region in the address space.
 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) {
+if (mapped_base != NULL && size > 0 && si->mapped_from_file()) {
-return;
+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)) {
-char* addr = region_addr(i);
+fatal("os::unmap_memory failed");
-if (!os::unmap_memory(addr, size)) {
+}
-fail_stop("Unable to unmap shared space.");
+si->set_mapped_base(NULL);
 }
 }
 void FileMapInfo::assert_mark(bool check) {
 if (!check) {
 // Validation of the archive is done in two steps:
 //
 // [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()) {
 // CDS assumes that no classes resolved in SystemDictionary::resolve_well_known_classes
 // are replaced at runtime by JVMTI ClassFileLoadHook. All of those classes are resolved
 }
 if (!open_for_read()) {
 return false;
 }
+if (!init_from_file(_fd)) {
-init_from_file(_fd, is_static);
+return false;
-// UseSharedSpaces could be disabled if the checking of some of the header fields in
+}
-// init_from_file has failed.
+if (!validate_header()) {
-if (!UseSharedSpaces || !validate_header(is_static)) {
 return false;
 }
 return true;
 }
 if (HeapShared::is_heap_region(idx)) {
 assert(DumpSharedSpaces, "The following doesn't work at runtime");
 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
 return crc;
 }
 // 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 ".",
 _obj_alignment, ObjectAlignmentInBytes);
 return false;
 }
 return true;
 }
-bool FileMapInfo::validate_header(bool is_static) {
+bool FileMapInfo::validate_header() {
 return header()->validate();
 }
 // Check if a given address is within one of the shared regions
 bool FileMapInfo::is_in_shared_region(const void* p, int idx) {
 return false;
 }
 // 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);
+map_info->unmap_region(i);
-if (addr != NULL) {
-map_info->unmap_region(i);
-map_info->space_at(i)->mark_invalid();
-}
 }
 }
 // Dealloc the archive heap regions only without unmapping. The regions are part
 // of the java heap. Unmapping of the heap regions are managed by GC.
 map_info->dealloc_archive_heap_regions(open_archive_heap_ranges,

changeset 59070	22ee476cc664
parent 58447	319173c62caa
child 59128	ac11b83e0f38