< prev index next >

src/jdk.hotspot.agent/linux/native/libsaproc/ps_core.c

Print this page

*** 30,39 **** --- 30,40 ---- #include <stddef.h> #include <elf.h> #include <link.h> #include "libproc_impl.h" #include "salibelf.h" + #include "../../../../hotspot/share/include/cds.h" // This file has the libproc implementation to read core files. // For live processes, refer to ps_proc.c. Portions of this is adapted // /modelled after Solaris libproc.so (in particular Pcore.c)
*** 201,268 **** // With class sharing, pages are mapped from classes.jsa file. // The read-only class sharing pages are mapped as MAP_SHARED, // PROT_READ pages. These pages are not dumped into core dump. // With this workaround, these pages are read from classes.jsa. ! // FIXME: !HACK ALERT! ! // The format of sharing achive file header is needed to read shared heap ! // file mappings. For now, I am hard coding portion of FileMapHeader here. ! // Refer to filemap.hpp. ! ! // FileMapHeader describes the shared space data in the file to be ! // mapped. This structure gets written to a file. It is not a class, ! // so that the compilers don't add any compiler-private data to it. ! ! #define NUM_SHARED_MAPS 9 ! ! // Refer to FileMapInfo::_current_version in filemap.hpp ! #define CURRENT_ARCHIVE_VERSION 3 ! ! typedef unsigned char* address; ! typedef uintptr_t uintx; ! typedef intptr_t intx; ! ! struct FileMapHeader { ! int _magic; // identify file type. ! int _crc; // header crc checksum. ! int _version; // (from enum, above.) ! size_t _alignment; // how shared archive should be aligned ! int _obj_alignment; // value of ObjectAlignmentInBytes ! address _narrow_oop_base; // compressed oop encoding base ! int _narrow_oop_shift; // compressed oop encoding shift ! bool _compact_strings; // value of CompactStrings ! uintx _max_heap_size; // java max heap size during dumping ! int _narrow_oop_mode; // compressed oop encoding mode ! int _narrow_klass_shift; // save narrow klass base and shift ! address _narrow_klass_base; ! char* _misc_data_patching_start; ! char* _read_only_tables_start; ! address _cds_i2i_entry_code_buffers; ! size_t _cds_i2i_entry_code_buffers_size; ! size_t _core_spaces_size; // number of bytes allocated by the core spaces ! // (mc, md, ro, rw and od). ! ! ! struct space_info { ! int _crc; // crc checksum of the current space ! size_t _file_offset; // sizeof(this) rounded to vm page size ! union { ! char* _base; // copy-on-write base address ! intx _offset; // offset from the compressed oop encoding base, only used ! // by archive heap space ! } _addr; ! size_t _used; // for setting space top on read ! // 4991491 NOTICE These are C++ bool's in filemap.hpp and must match up with ! // the C type matching the C++ bool type on any given platform. ! // We assume the corresponding C type is char but licensees ! // may need to adjust the type of these fields. ! char _read_only; // read only space? ! char _allow_exec; // executable code in space? ! } _space[NUM_SHARED_MAPS]; ! ! // Ignore the rest of the FileMapHeader. We don't need those fields here. ! }; static bool read_jboolean(struct ps_prochandle* ph, uintptr_t addr, jboolean* pvalue) { jboolean i; if (ps_pdread(ph, (psaddr_t) addr, &i, sizeof(i)) == PS_OK) { *pvalue = i; --- 202,212 ---- // With class sharing, pages are mapped from classes.jsa file. // The read-only class sharing pages are mapped as MAP_SHARED, // PROT_READ pages. These pages are not dumped into core dump. // With this workaround, these pages are read from classes.jsa. ! typedef struct CDSFileMapHeaderBase FileMapHeader; static bool read_jboolean(struct ps_prochandle* ph, uintptr_t addr, jboolean* pvalue) { jboolean i; if (ps_pdread(ph, (psaddr_t) addr, &i, sizeof(i)) == PS_OK) { *pvalue = i;
*** 315,325 **** // we are iterating over shared objects from the core dump. look for // libjvm.so. const char *jvm_name = 0; if ((jvm_name = strstr(lib->name, LIBJVM_NAME)) != 0) { char classes_jsa[PATH_MAX]; ! struct FileMapHeader header; int fd = -1; int m = 0; size_t n = 0; uintptr_t base = 0, useSharedSpacesAddr = 0; uintptr_t sharedArchivePathAddrAddr = 0, sharedArchivePathAddr = 0; --- 259,269 ---- // we are iterating over shared objects from the core dump. look for // libjvm.so. const char *jvm_name = 0; if ((jvm_name = strstr(lib->name, LIBJVM_NAME)) != 0) { char classes_jsa[PATH_MAX]; ! FileMapHeader header; int fd = -1; int m = 0; size_t n = 0; uintptr_t base = 0, useSharedSpacesAddr = 0; uintptr_t sharedArchivePathAddrAddr = 0, sharedArchivePathAddr = 0;
*** 373,409 **** } else { print_debug("opened %s\n", classes_jsa); } // read FileMapHeader from the file ! memset(&header, 0, sizeof(struct FileMapHeader)); ! if ((n = read(fd, &header, sizeof(struct FileMapHeader))) ! != sizeof(struct FileMapHeader)) { print_debug("can't read shared archive file map header from %s\n", classes_jsa); close(fd); return false; } // check file magic ! if (header._magic != 0xf00baba2) { ! print_debug("%s has bad shared archive file magic number 0x%x, expecing 0xf00baba2\n", ! classes_jsa, header._magic); close(fd); return false; } // check version ! if (header._version != CURRENT_ARCHIVE_VERSION) { print_debug("%s has wrong shared archive file version %d, expecting %d\n", ! classes_jsa, header._version, CURRENT_ARCHIVE_VERSION); close(fd); return false; } ph->core->classes_jsa_fd = fd; // add read-only maps from classes.jsa to the list of maps ! for (m = 0; m < NUM_SHARED_MAPS; m++) { if (header._space[m]._read_only) { base = (uintptr_t) header._space[m]._addr._base; // no need to worry about the fractional pages at-the-end. // possible fractional pages are handled by core_read_data. add_class_share_map_info(ph, (off_t) header._space[m]._file_offset, --- 317,353 ---- } else { print_debug("opened %s\n", classes_jsa); } // read FileMapHeader from the file ! memset(&header, 0, sizeof(FileMapHeader)); ! if ((n = read(fd, &header, sizeof(FileMapHeader))) ! != sizeof(FileMapHeader)) { print_debug("can't read shared archive file map header from %s\n", classes_jsa); close(fd); return false; } // check file magic ! if (header._magic != CDS_ARCHIVE_MAGIC) { ! print_debug("%s has bad shared archive file magic number 0x%x, expecing 0x%x\n", ! classes_jsa, header._magic, CDS_ARCHIVE_MAGIC); close(fd); return false; } // check version ! if (header._version != CURRENT_CDS_ARCHIVE_VERSION) { print_debug("%s has wrong shared archive file version %d, expecting %d\n", ! classes_jsa, header._version, CURRENT_CDS_ARCHIVE_VERSION); close(fd); return false; } ph->core->classes_jsa_fd = fd; // add read-only maps from classes.jsa to the list of maps ! for (m = 0; m < NUM_CDS_REGIONS; m++) { if (header._space[m]._read_only) { base = (uintptr_t) header._space[m]._addr._base; // no need to worry about the fractional pages at-the-end. // possible fractional pages are handled by core_read_data. add_class_share_map_info(ph, (off_t) header._space[m]._file_offset,
< prev index next >