infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-05-11 05:59:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

8276790: Rename GenericCDSFileMapHeader::_base_archive_path_offset

Browse Source 
Reviewed-by: dholmes, ccheung
This commit is contained in:
Ioi Lam 2021-11-09 07:18:06 +00:00
parent 38e6d5d6ed
commit 8747882e4c
7 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/hotspot/share/cds/cdsConstants.cpp
View File

@ -35,7 +35,7 @@ CDSConst CDSConstants::offsets[] = {
{ "GenericCDSFileMapHeader::_crc", offset_of(GenericCDSFileMapHeader, _crc) },
{ "GenericCDSFileMapHeader::_version", offset_of(GenericCDSFileMapHeader, _version) },
{ "GenericCDSFileMapHeader::_header_size", offset_of(GenericCDSFileMapHeader, _header_size) },
{ "GenericCDSFileMapHeader::_base_archive_path_offset", offset_of(GenericCDSFileMapHeader, _base_archive_path_offset) },
{ "GenericCDSFileMapHeader::_base_archive_name_offset", offset_of(GenericCDSFileMapHeader, _base_archive_name_offset) },
{ "GenericCDSFileMapHeader::_base_archive_name_size", offset_of(GenericCDSFileMapHeader, _base_archive_name_size) },
{ "CDSFileMapHeaderBase::_space[0]", offset_of(CDSFileMapHeaderBase, _space) },
{ "FileMapHeader::_jvm_ident", offset_of(FileMapHeader, _jvm_ident) },

42
src/hotspot/share/cds/filemap.cpp
View File

@ -196,7 +196,7 @@ void FileMapInfo::populate_header(size_t core_region_alignment) {
size_t c_header_size;
size_t header_size;
size_t base_archive_name_size = 0;
size_t base_archive_path_offset = 0;
size_t base_archive_name_offset = 0;
if (is_static()) {
c_header_size = sizeof(FileMapHeader);
header_size = c_header_size;
@ -207,7 +207,7 @@ void FileMapInfo::populate_header(size_t core_region_alignment) {
if (!FLAG_IS_DEFAULT(SharedArchiveFile)) {
base_archive_name_size = strlen(Arguments::GetSharedArchivePath()) + 1;
header_size += base_archive_name_size;
base_archive_path_offset = c_header_size;
base_archive_name_offset = c_header_size;
}
}
_header = (FileMapHeader*)os::malloc(header_size, mtInternal);
@ -216,17 +216,17 @@ void FileMapInfo::populate_header(size_t core_region_alignment) {
core_region_alignment,
header_size,
base_archive_name_size,
base_archive_path_offset);
base_archive_name_offset);
}
void FileMapHeader::populate(FileMapInfo *info, size_t core_region_alignment,
size_t header_size, size_t base_archive_name_size,
size_t base_archive_path_offset) {
size_t base_archive_name_offset) {
// 1. We require _generic_header._magic to be at the beginning of the file
// 2. FileMapHeader also assumes that _generic_header is at the beginning of the file
assert(offset_of(FileMapHeader, _generic_header) == 0, "must be");
set_header_size((unsigned int)header_size);
set_base_archive_path_offset((unsigned int)base_archive_path_offset);
set_base_archive_name_offset((unsigned int)base_archive_name_offset);
set_base_archive_name_size((unsigned int)base_archive_name_size);
set_magic(DynamicDumpSharedSpaces ? CDS_DYNAMIC_ARCHIVE_MAGIC : CDS_ARCHIVE_MAGIC);
set_version(CURRENT_CDS_ARCHIVE_VERSION);
@ -280,9 +280,9 @@ void FileMapHeader::populate(FileMapInfo *info, size_t core_region_alignment,
void FileMapHeader::copy_base_archive_name(const char* archive) {
assert(base_archive_name_size() != 0, "_base_archive_name_size not set");
assert(base_archive_path_offset() != 0, "_base_archive_path_offset not set");
assert(base_archive_name_offset() != 0, "_base_archive_name_offset not set");
assert(header_size() > sizeof(*this), "_base_archive_name_size not included in header size?");
memcpy((char*)this + base_archive_path_offset(), archive, base_archive_name_size());
memcpy((char*)this + base_archive_name_offset(), archive, base_archive_name_size());
}
void FileMapHeader::print(outputStream* st) {
@ -292,7 +292,7 @@ void FileMapHeader::print(outputStream* st) {
st->print_cr("- crc: 0x%08x", crc());
st->print_cr("- version: %d", version());
st->print_cr("- header_size: " UINT32_FORMAT, header_size());
st->print_cr("- base_archive_path_offset: " UINT32_FORMAT, base_archive_path_offset());
st->print_cr("- base_archive_name_offset: " UINT32_FORMAT, base_archive_name_offset());
st->print_cr("- base_archive_name_size: " UINT32_FORMAT, base_archive_name_size());
for (int i = 0; i < NUM_CDS_REGIONS; i++) {
@ -1088,7 +1088,7 @@ public:
size_t name_size = _header._base_archive_name_size;
assert(name_size != 0, "For non-default base archive, name size should be non-zero!");
char* base_name = NEW_C_HEAP_ARRAY(char, name_size, mtInternal);
lseek(_fd, _header._base_archive_path_offset, SEEK_SET); // position to correct offset.
lseek(_fd, _header._base_archive_name_offset, SEEK_SET); // position to correct offset.
size_t n = os::read(_fd, base_name, (unsigned int)name_size);
if (n != name_size) {
log_info(cds)("Unable to read base archive name from archive");
@ -1124,9 +1124,9 @@ bool FileMapInfo::check_archive(const char* archive_name, bool is_static) {
vm_exit_during_initialization("Not a base shared archive", archive_name);
return false;
}
if (header->_base_archive_path_offset != 0) {
log_info(cds)("_base_archive_path_offset should be 0");
log_info(cds)("_base_archive_path_offset = " UINT32_FORMAT, header->_base_archive_path_offset);
if (header->_base_archive_name_offset != 0) {
log_info(cds)("_base_archive_name_offset should be 0");
log_info(cds)("_base_archive_name_offset = " UINT32_FORMAT, header->_base_archive_name_offset);
return false;
}
} else {
@ -1135,12 +1135,12 @@ bool FileMapInfo::check_archive(const char* archive_name, bool is_static) {
return false;
}
unsigned int name_size = header->_base_archive_name_size;
unsigned int path_offset = header->_base_archive_path_offset;
unsigned int name_offset = header->_base_archive_name_offset;
unsigned int header_size = header->_header_size;
if (path_offset + name_size != header_size) {
log_info(cds)("_header_size should be equal to _base_archive_path_offset plus _base_archive_name_size");
if (name_offset + name_size != header_size) {
log_info(cds)("_header_size should be equal to _base_archive_name_offset plus _base_archive_name_size");
log_info(cds)(" _base_archive_name_size = " UINT32_FORMAT, name_size);
log_info(cds)(" _base_archive_path_offset = " UINT32_FORMAT, path_offset);
log_info(cds)(" _base_archive_name_offset = " UINT32_FORMAT, name_offset);
log_info(cds)(" _header_size = " UINT32_FORMAT, header_size);
return false;
}
@ -1165,13 +1165,13 @@ bool FileMapInfo::get_base_archive_name_from_header(const char* archive_name,
return false;
}
if ((header->_base_archive_name_size == 0 && header->_base_archive_path_offset != 0) ||
(header->_base_archive_name_size != 0 && header->_base_archive_path_offset == 0)) {
if ((header->_base_archive_name_size == 0 && header->_base_archive_name_offset != 0) ||
(header->_base_archive_name_size != 0 && header->_base_archive_name_offset == 0)) {
fail_continue("Default base archive not set correct");
return false;
}
if (header->_base_archive_name_size == 0 &&
header->_base_archive_path_offset == 0) {
header->_base_archive_name_offset == 0) {
*base_archive_name = Arguments::get_default_shared_archive_path();
} else {
// read the base archive name
@ -1217,14 +1217,14 @@ bool FileMapInfo::init_from_file(int fd) {
return false;
}
unsigned int base_offset = header()->base_archive_path_offset();
unsigned int base_offset = header()->base_archive_name_offset();
unsigned int name_size = header()->base_archive_name_size();
unsigned int header_size = header()->header_size();
if (base_offset != 0 && name_size != 0) {
if (header_size != base_offset + name_size) {
log_info(cds)("_header_size: " UINT32_FORMAT, header_size);
log_info(cds)("base_archive_name_size: " UINT32_FORMAT, name_size);
log_info(cds)("base_archive_path_offset: " UINT32_FORMAT, base_offset);
log_info(cds)("base_archive_name_offset: " UINT32_FORMAT, base_offset);
FileMapInfo::fail_continue("The shared archive file has an incorrect header size.");
return false;
}

6
src/hotspot/share/cds/filemap.hpp
View File

@ -243,14 +243,14 @@ public:
int crc() const { return _generic_header._crc; }
int version() const { return _generic_header._version; }
unsigned int header_size() const { return _generic_header._header_size; }
unsigned int base_archive_path_offset() const { return _generic_header._base_archive_path_offset; }
unsigned int base_archive_name_offset() const { return _generic_header._base_archive_name_offset; }
unsigned int base_archive_name_size() const { return _generic_header._base_archive_name_size; }
void set_magic(unsigned int m) { _generic_header._magic = m; }
void set_crc(int crc_value) { _generic_header._crc = crc_value; }
void set_version(int v) { _generic_header._version = v; }
void set_header_size(unsigned int s) { _generic_header._header_size = s; }
void set_base_archive_path_offset(unsigned int s) { _generic_header._base_archive_path_offset = s; }
void set_base_archive_name_offset(unsigned int s) { _generic_header._base_archive_name_offset = s; }
void set_base_archive_name_size(unsigned int s) { _generic_header._base_archive_name_size = s; }
size_t core_region_alignment() const { return _core_region_alignment; }
@ -313,7 +313,7 @@ public:
}
void populate(FileMapInfo *info, size_t core_region_alignment, size_t header_size,
size_t base_archive_name_size, size_t base_archive_path_offset);
size_t base_archive_name_size, size_t base_archive_name_offset);
static bool is_valid_region(int region) {
return (0 <= region && region < NUM_CDS_REGIONS);
}

4
src/hotspot/share/include/cds.h
View File

@ -67,12 +67,12 @@ typedef struct GenericCDSFileMapHeader {
int _crc; // header crc checksum
int _version; // CURRENT_CDS_ARCHIVE_VERSION of the jdk that dumped the this archive
unsigned int _header_size; // total size of the header, in bytes
unsigned int _base_archive_path_offset; // offset where the base archive name is stored
unsigned int _base_archive_name_offset; // offset where the base archive name is stored
// static archive: 0
// dynamic archive:
// 0 for default base archive
// non-zero for non-default base archive
// (char*)this + _base_archive_path_offset
// (char*)this + _base_archive_name_offset
// points to a 0-terminated string for the base archive name
unsigned int _base_archive_name_size; // size of base archive name including ending '\0'
// static: 0

18
test/hotspot/jtreg/runtime/cds/appcds/SharedArchiveConsistency.java
View File

@ -222,15 +222,15 @@ public class SharedArchiveConsistency {
CDSArchiveUtils.modifyRegionContentRandomly(copiedJsa);
testAndCheck(verifyExecArgs);
// modify _base_archive_path_offet to non-zero
System.out.println("\n8. modify _base_archive_path_offset to non-zero\n");
String baseArchivePathOffsetName = startNewArchive("base-arhive-path-offset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(orgJsaFile, baseArchivePathOffsetName);
int baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
System.out.println(" baseArchivePathOffset = " + baseArchivePathOffset);
CDSArchiveUtils.writeData(copiedJsa, CDSArchiveUtils.offsetBaseArchivePathOffset(), 1024);
baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
System.out.println("new baseArchivePathOffset = " + baseArchivePathOffset);
// modify _base_archive_name_offet to non-zero
System.out.println("\n8. modify _base_archive_name_offset to non-zero\n");
String baseArchiveNameOffsetName = startNewArchive("base-arhive-path-offset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(orgJsaFile, baseArchiveNameOffsetName);
int baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
System.out.println(" baseArchiveNameOffset = " + baseArchiveNameOffset);
CDSArchiveUtils.writeData(copiedJsa, CDSArchiveUtils.offsetBaseArchiveNameOffset(), 1024);
baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
System.out.println("new baseArchiveNameOffset = " + baseArchiveNameOffset);
testAndCheck(verifyExecArgs);
}
}

34
test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/ArchiveConsistency.java
View File

@ -112,31 +112,31 @@ public class ArchiveConsistency extends DynamicArchiveTestBase {
CDSArchiveUtils.modifyHeaderIntField(copiedJsa, CDSArchiveUtils.offsetHeaderSize(), (int)copiedJsa.length() + 1024);
runTwo(baseArchiveName, largerHeaderSize,
appJar, mainClass, 1,
new String[] {"_header_size should be equal to _base_archive_path_offset plus _base_archive_name_size",
new String[] {"_header_size should be equal to _base_archive_name_offset plus _base_archive_name_size",
"Unable to use shared archive"});
// 3. Make base archive path offset beyond of header size
System.out.println("\n3. Make base archive path offset beyond of header size.");
String wrongBaseArchivePathOffset = getNewArchiveName("wrongBaseArchivePathOffset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBaseArchivePathOffset);
String wrongBaseArchiveNameOffset = getNewArchiveName("wrongBaseArchiveNameOffset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBaseArchiveNameOffset);
int fileHeaderSize = (int)CDSArchiveUtils.fileHeaderSize(copiedJsa);
int baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
CDSArchiveUtils.modifyHeaderIntField(copiedJsa, CDSArchiveUtils.offsetBaseArchivePathOffset(), baseArchivePathOffset + 1024);
runTwo(baseArchiveName, wrongBaseArchivePathOffset,
int baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
CDSArchiveUtils.modifyHeaderIntField(copiedJsa, CDSArchiveUtils.offsetBaseArchiveNameOffset(), baseArchiveNameOffset + 1024);
runTwo(baseArchiveName, wrongBaseArchiveNameOffset,
appJar, mainClass, 1,
new String[] {"_header_size should be equal to _base_archive_path_offset plus _base_archive_name_size",
new String[] {"_header_size should be equal to _base_archive_name_offset plus _base_archive_name_size",
"The shared archive file has an incorrect header size",
"Unable to use shared archive"});
// 4. Make base archive path offset points to middle of name size
System.out.println("\n4. Make base archive path offset points to middle of name size");
String wrongBasePathOffset = getNewArchiveName("wrongBasePathOffset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBasePathOffset);
String wrongBaseNameOffset = getNewArchiveName("wrongBaseNameOffset");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBaseNameOffset);
int baseArchiveNameSize = CDSArchiveUtils.baseArchiveNameSize(copiedJsa);
baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
CDSArchiveUtils.modifyHeaderIntField(copiedJsa, baseArchivePathOffset,
baseArchivePathOffset + baseArchiveNameSize/2);
runTwo(baseArchiveName, wrongBasePathOffset,
baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
CDSArchiveUtils.modifyHeaderIntField(copiedJsa, baseArchiveNameOffset,
baseArchiveNameOffset + baseArchiveNameSize/2);
runTwo(baseArchiveName, wrongBaseNameOffset,
appJar, mainClass, 1,
new String[] {"An error has occurred while processing the shared archive file.",
"Header checksum verification failed",
@ -146,9 +146,9 @@ public class ArchiveConsistency extends DynamicArchiveTestBase {
System.out.println("\n5. Make base archive name not terminated with '\0'");
String wrongBaseName = getNewArchiveName("wrongBaseName");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBaseName);
baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
baseArchiveNameSize = CDSArchiveUtils.baseArchiveNameSize(copiedJsa);
long offset = baseArchivePathOffset + baseArchiveNameSize - 1; // end of line
long offset = baseArchiveNameOffset + baseArchiveNameSize - 1; // end of line
CDSArchiveUtils.writeData(copiedJsa, offset, new byte[] {(byte)'X'});
runTwo(baseArchiveName, wrongBaseName,
@ -160,9 +160,9 @@ public class ArchiveConsistency extends DynamicArchiveTestBase {
System.out.println("\n6. Modify base archive name to a file that doesn't exist");
String wrongBaseName2 = getNewArchiveName("wrongBaseName2");
copiedJsa = CDSArchiveUtils.copyArchiveFile(jsa, wrongBaseName2);
baseArchivePathOffset = CDSArchiveUtils.baseArchivePathOffset(copiedJsa);
baseArchiveNameOffset = CDSArchiveUtils.baseArchiveNameOffset(copiedJsa);
baseArchiveNameSize = CDSArchiveUtils.baseArchiveNameSize(copiedJsa);
offset = baseArchivePathOffset + baseArchiveNameSize - 2; // the "a" in ".jsa"
offset = baseArchiveNameOffset + baseArchiveNameSize - 2; // the "a" in ".jsa"
CDSArchiveUtils.writeData(copiedJsa, offset, new byte[] {(byte)'b'}); // .jsa -> .jsb
// Make sure it doesn't exist

14
test/lib/jdk/test/lib/cds/CDSArchiveUtils.java
View File

@ -50,7 +50,7 @@ public class CDSArchiveUtils {
private static int offsetCrc; // offset of GenericCDSFileMapHeader::_crc
private static int offsetVersion; // offset of GenericCDSFileMapHeader::_version
private static int offsetHeaderSize; // offset of GenericCDSFileMapHeader::_header_size
private static int offsetBaseArchivePathOffset;// offset of GenericCDSFileMapHeader::_base_archive_path_offset
private static int offsetBaseArchiveNameOffset;// offset of GenericCDSFileMapHeader::_base_archive_name_offset
private static int offsetBaseArchiveNameSize; // offset of GenericCDSFileMapHeader::_base_archive_name_size
private static int offsetJvmIdent; // offset of FileMapHeader::_jvm_ident
private static int spOffsetCrc; // offset of CDSFileMapRegion::_crc
@ -87,7 +87,7 @@ public class CDSArchiveUtils {
offsetCrc = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_crc");
offsetVersion = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_version");
offsetHeaderSize = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_header_size");
offsetBaseArchivePathOffset = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_base_archive_path_offset");
offsetBaseArchiveNameOffset = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_base_archive_name_offset");
offsetBaseArchiveNameSize = wb.getCDSOffsetForName("GenericCDSFileMapHeader::_base_archive_name_size");
offsetJvmIdent = wb.getCDSOffsetForName("FileMapHeader::_jvm_ident");
spOffsetCrc = wb.getCDSOffsetForName("CDSFileMapRegion::_crc");
@ -121,7 +121,7 @@ public class CDSArchiveUtils {
public static int offsetCrc() { return offsetCrc; }
public static int offsetVersion() { return offsetVersion; }
public static int offsetHeaderSize() { return offsetHeaderSize; }
public static int offsetBaseArchivePathOffset() { return offsetBaseArchivePathOffset; }
public static int offsetBaseArchiveNameOffset() { return offsetBaseArchiveNameOffset; }
public static int offsetBaseArchiveNameSize() { return offsetBaseArchiveNameSize; }
public static int offsetJvmIdent() { return offsetJvmIdent; }
public static int spOffsetCrc() { return spOffsetCrc; }
@ -148,8 +148,8 @@ public class CDSArchiveUtils {
return alignUpWithAlignment(size);
}
public static int baseArchivePathOffset(File jsaFile) throws Exception {
return (int)readInt(jsaFile, offsetBaseArchivePathOffset, 4);
public static int baseArchiveNameOffset(File jsaFile) throws Exception {
return (int)readInt(jsaFile, offsetBaseArchiveNameOffset, 4);
}
public static int baseArchiveNameSize(File jsaFile) throws Exception {
@ -158,8 +158,8 @@ public class CDSArchiveUtils {
public static String baseArchiveName(File jsaFile) throws Exception {
int size = baseArchiveNameSize(jsaFile);
int baseArchivePathOffset = (int)readInt(jsaFile, offsetBaseArchivePathOffset, 4);
return readString(jsaFile, baseArchivePathOffset, size - 1); // exclude terminating '\0'
int baseArchiveNameOffset = (int)readInt(jsaFile, offsetBaseArchiveNameOffset, 4);
return readString(jsaFile, baseArchiveNameOffset, size - 1); // exclude terminating '\0'
}
private static long alignUpWithAlignment(long l) {