jdk8-mips64-public/hotspot: src/share/vm/memory/filemap.hpp@8cb56c8cb30d (annotated)

src/share/vm/memory/filemap.hpp@8cb56c8cb30d (annotated)

src/share/vm/memory/filemap.hpp

Mon, 15 Sep 2014 16:39:00 -0400

author: jiangli
date: Mon, 15 Sep 2014 16:39:00 -0400
changeset 7241: 8cb56c8cb30d
parent 7089: 6e0cb14ce59b
parent 6868: ca6d25be853b
child 7535: 7ae4e26cb1e0
permissions: -rw-r--r--

Merge

 /*
  * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #ifndef SHARE_VM_MEMORY_FILEMAP_HPP
 #define SHARE_VM_MEMORY_FILEMAP_HPP
 #include "memory/metaspaceShared.hpp"
 #include "memory/metaspace.hpp"
 // Layout of the file:
 //  header: dump of archive instance plus versioning info, datestamp, etc.
 //   [magic # = 0xF00BABA2]
 //  ... padding to align on page-boundary
 //  read-write space from CompactingPermGenGen
 //  read-only space from CompactingPermGenGen
 //  misc data (block offset table, string table, symbols, dictionary, etc.)
 //  tag(666)
 static const int JVM_IDENT_MAX = 256;
 class Metaspace;
 class SharedClassPathEntry VALUE_OBJ_CLASS_SPEC {
 public:
   const char *_name;
   time_t _timestamp;          // jar timestamp,  0 if is directory
   long   _filesize;           // jar file size, -1 if is directory
   bool is_dir() {
     return _filesize == -1;
   }
 };
 class FileMapInfo : public CHeapObj<mtInternal> {
 private:
   friend class ManifestStream;
   enum {
     _invalid_version = -1,
     _current_version = 2
   };
   bool  _file_open;
   int   _fd;
   size_t  _file_offset;
 private:
   static SharedClassPathEntry* _classpath_entry_table;
   static int                   _classpath_entry_table_size;
   static size_t                _classpath_entry_size;
   static bool                  _validating_classpath_entry_table;
   // 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.
 public:
   struct FileMapHeaderBase : public CHeapObj<mtClass> {
     virtual bool validate() = 0;
     virtual void populate(FileMapInfo* info, size_t alignment) = 0;
   };
   struct FileMapHeader : FileMapHeaderBase {
     // Use data() and data_size() to memcopy to/from the FileMapHeader. We need to
     // avoid read/writing the C++ vtable pointer.
     static size_t data_size();
     char* data() {
       return ((char*)this) + sizeof(FileMapHeaderBase);
     }
     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
     struct space_info {
       int    _crc;           // crc checksum of the current space
       size_t _file_offset;   // sizeof(this) rounded to vm page size
       char*  _base;          // copy-on-write base address
       size_t _capacity;      // for validity checking
       size_t _used;          // for setting space top on read
       bool   _read_only;     // read only space?
       bool   _allow_exec;    // executable code in space?
     } _space[MetaspaceShared::n_regions];
     // The following fields are all sanity checks for whether this archive
     // will function correctly with this JVM and the bootclasspath it's
     // invoked with.
     char  _jvm_ident[JVM_IDENT_MAX];      // identifier for jvm
     // The _paths_misc_info is a variable-size structure that records "miscellaneous"
     // information during dumping. It is generated and validated by the
     // SharedPathsMiscInfo class. See SharedPathsMiscInfo.hpp and sharedClassUtil.hpp for
     // detailed description.
     //
     // The _paths_misc_info data is stored as a byte array in the archive file header,
     // immediately after the _header field. This information is used only when
     // checking the validity of the archive and is deallocated after the archive is loaded.
     //
     // Note that the _paths_misc_info does NOT include information for JAR files
     // that existed during dump time. Their information is stored in _classpath_entry_table.
     int _paths_misc_info_size;
     // The following is a table of all the class path entries that were used
     // during dumping. At run time, we require these files to exist and have the same
     // size/modification time, or else the archive will refuse to load.
     //
     // All of these entries must be JAR files. The dumping process would fail if a non-empty
     // directory was specified in the classpaths. If an empty directory was specified
     // it is checked by the _paths_misc_info as described above.
     //
     // FIXME -- if JAR files in the tail of the list were specified but not used during dumping,
     // they should be removed from this table, to save space and to avoid spurious
     // loading failures during runtime.
     int _classpath_entry_table_size;
     size_t _classpath_entry_size;
     SharedClassPathEntry* _classpath_entry_table;
     virtual bool validate();
     virtual void populate(FileMapInfo* info, size_t alignment);
     int compute_crc();
   };
   FileMapHeader * _header;
   const char* _full_path;
   char* _paths_misc_info;
   static FileMapInfo* _current_info;
   bool  init_from_file(int fd);
   void  align_file_position();
   bool  validate_header_impl();
 public:
   FileMapInfo();
   ~FileMapInfo();
   static int current_version()        { return _current_version; }
   int    compute_header_crc();
   void   set_header_crc(int crc)      { _header->_crc = crc; }
   void   populate_header(size_t alignment);
   bool   validate_header();
   void   invalidate();
   int    version()                    { return _header->_version; }
   size_t alignment()                  { return _header->_alignment; }
   size_t space_capacity(int i)        { return _header->_space[i]._capacity; }
   char*  region_base(int i)           { return _header->_space[i]._base; }
   struct FileMapHeader* header()      { return _header; }
   static FileMapInfo* current_info() {
     CDS_ONLY(return _current_info;)
     NOT_CDS(return NULL;)
   }
   static void assert_mark(bool check);
   // File manipulation.
   bool  initialize() NOT_CDS_RETURN_(false);
   bool  open_for_read();
   void  open_for_write();
   void  write_header();
   void  write_space(int i, Metaspace* space, bool read_only);
   void  write_region(int region, char* base, size_t size,
                      size_t capacity, bool read_only, bool allow_exec);
   void  write_bytes(const void* buffer, int count);
   void  write_bytes_aligned(const void* buffer, int count);
   char* map_region(int i);
   void  unmap_region(int i);
   bool  verify_region_checksum(int i);
   void  close();
   bool  is_open() { return _file_open; }
   ReservedSpace reserve_shared_memory();
   // JVM/TI RedefineClasses() support:
   // Remap the shared readonly space to shared readwrite, private.
   bool  remap_shared_readonly_as_readwrite();
   // Errors.
   static void fail_stop(const char *msg, ...);
   static void fail_continue(const char *msg, ...);
   // Return true if given address is in the mapped shared space.
   bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false);
   void print_shared_spaces() NOT_CDS_RETURN;
   static size_t shared_spaces_size() {
     return align_size_up(SharedReadOnlySize + SharedReadWriteSize +
                          SharedMiscDataSize + SharedMiscCodeSize,
                          os::vm_allocation_granularity());
   }
   // Stop CDS sharing and unmap CDS regions.
   static void stop_sharing_and_unmap(const char* msg);
   static void allocate_classpath_entry_table();
   bool validate_classpath_entry_table();
   static SharedClassPathEntry* shared_classpath(int index) {
     char* p = (char*)_classpath_entry_table;
     p += _classpath_entry_size * index;
     return (SharedClassPathEntry*)p;
   }
   static const char* shared_classpath_name(int index) {
     return shared_classpath(index)->_name;
   }
   static int get_number_of_share_classpaths() {
     return _classpath_entry_table_size;
   }
 };
 #endif // SHARE_VM_MEMORY_FILEMAP_HPP

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/memory/filemap.hpp@8cb56c8cb30d (annotated)

src/share/vm/memory/filemap.hpp